/* given opt, create a new opt with equal-constraint dimensions eliminated */
static nlopt_opt elimdim_create(nlopt_opt opt)
{
nlopt_opt opt0 = nlopt_copy(opt);
double *x, *grad = NULL;
unsigned i;
if (!opt0) return NULL;
x = (double *) malloc(sizeof(double) * opt->n);
if (opt->n && !x) { nlopt_destroy(opt0); return NULL; }
if (opt->algorithm == NLOPT_GD_STOGO
|| opt->algorithm == NLOPT_GD_STOGO_RAND) {
grad = (double *) malloc(sizeof(double) * opt->n);
if (opt->n && !grad) goto bad;
}
opt0->n = elimdim_dimension(opt->n, opt->lb, opt->ub);
elimdim_shrink(opt->n, opt0->lb, opt->lb, opt->ub);
elimdim_shrink(opt->n, opt0->ub, opt->lb, opt->ub);
elimdim_shrink(opt->n, opt0->xtol_abs, opt->lb, opt->ub);
elimdim_shrink(opt->n, opt0->dx, opt->lb, opt->ub);
opt0->munge_on_destroy = opt0->munge_on_copy = NULL;
opt0->f = elimdim_func;
opt0->f_data = elimdim_makedata(opt->f, NULL, opt->f_data,
opt->n, x, opt->lb, opt->ub, grad);
if (!opt0->f_data) goto bad;
for (i = 0; i < opt->m; ++i) {
opt0->fc[i].f = elimdim_func;
opt0->fc[i].mf = elimdim_mfunc;
opt0->fc[i].f_data = elimdim_makedata(opt->fc[i].f, opt->fc[i].mf,
opt->fc[i].f_data,
opt->n, x, opt->lb, opt->ub,
NULL);
if (!opt0->fc[i].f_data) goto bad;
}
for (i = 0; i < opt->p; ++i) {
opt0->h[i].f = elimdim_func;
opt0->h[i].mf = elimdim_mfunc;
opt0->h[i].f_data = elimdim_makedata(opt->h[i].f, opt->h[i].mf,
opt->h[i].f_data,
opt->n, x, opt->lb, opt->ub,
NULL);
if (!opt0->h[i].f_data) goto bad;
}
return opt0;
bad:
free(grad);
free(x);
nlopt_destroy(opt0);
return NULL;
}
void NLOPT_STDCALL nlopt_destroy(nlopt_opt opt)
{
if (opt) {
unsigned i;
if (opt->munge_on_destroy) {
nlopt_munge munge = opt->munge_on_destroy;
munge(opt->f_data);
for (i = 0; i < opt->m; ++i)
munge(opt->fc[i].f_data);
for (i = 0; i < opt->p; ++i)
munge(opt->h[i].f_data);
}
for (i = 0; i < opt->m; ++i)
free(opt->fc[i].tol);
for (i = 0; i < opt->p; ++i)
free(opt->h[i].tol);
free(opt->lb); free(opt->ub);
free(opt->xtol_abs);
free(opt->fc);
free(opt->h);
nlopt_destroy(opt->local_opt);
free(opt->dx);
free(opt->work);
free(opt);
}
}
int main() {
double lb[2] = { -HUGE_VAL, 0 }; /* lower bounds */
nlopt_opt opt;
opt = nlopt_create(NLOPT_LD_MMA, 2); /* algorithm and dimensionality */
nlopt_set_lower_bounds(opt, lb);
nlopt_set_min_objective(opt, myfunc, NULL);
my_constraint_data data[2] = { { 2, 0 }, { -1, 1 } };
nlopt_add_inequality_constraint(opt, myconstraint, &data[0], 1e-8);
nlopt_add_inequality_constraint(opt, myconstraint, &data[1], 1e-8);
nlopt_set_xtol_rel(opt, 1e-4);
double x[2] = { 1.234, 5.678 }; /* some initial guess */
double minf; /* the minimum objective value, upon return */
if (nlopt_optimize(opt, x, &minf) < 0) {
printf("nlopt failed!\n");
}
else {
printf("found minimum at f(%g,%g) = %0.10g\n", x[0], x[1], minf);
}
nlopt_destroy(opt);
}
static void phyanimal_fit_lambda(PhyAnimal model) {
nlopt_opt opt;
double lb, ub, lambda, loglh;
opt = nlopt_create(NLOPT_LN_NELDERMEAD, 1); /* one dimension */
lb = 0.0;
ub = 1.0;
nlopt_set_lower_bounds(opt,&lb);
nlopt_set_upper_bounds(opt,&ub);
/* No inequality constraints */
nlopt_set_max_objective(opt, loglh_worker, model);
nlopt_set_xtol_rel(opt, 1e-4);
lambda = 0.1;
if (nlopt_optimize(opt, &lambda, &loglh)<0) {
printf("NLOPT failed\n");
} else {
printf("Maximum lh %f at lambda %f\n",loglh,lambda);
printf("Sigma = %f\n",model->sigma);
printf("Sigma_b = %f\nSigma_e = %f\n",model->sigma*lambda,model->sigma*(1-lambda));
}
model->loglh = loglh;
model->lambda = lambda;
nlopt_destroy(opt);
return;
}
void NloptOptimizationSolver<T>::clear ()
{
if (this->initialized())
{
this->_is_initialized = false;
nlopt_destroy(_opt);
}
}
nlopt_opt NLOPT_STDCALL nlopt_create(nlopt_algorithm algorithm, unsigned n)
{
nlopt_opt opt;
if (((int) algorithm) < 0 || algorithm >= NLOPT_NUM_ALGORITHMS)
return NULL;
opt = (nlopt_opt) malloc(sizeof(struct nlopt_opt_s));
if (opt) {
opt->algorithm = algorithm;
opt->n = n;
opt->f = NULL; opt->f_data = NULL; opt->pre = NULL;
opt->maximize = 0;
opt->munge_on_destroy = opt->munge_on_copy = NULL;
opt->lb = opt->ub = NULL;
opt->m = opt->m_alloc = 0;
opt->fc = NULL;
opt->p = opt->p_alloc = 0;
opt->h = NULL;
opt->stopval = -HUGE_VAL;
opt->ftol_rel = opt->ftol_abs = 0;
opt->xtol_rel = 0; opt->xtol_abs = NULL;
opt->maxeval = 0;
opt->maxtime = 0;
opt->force_stop = 0;
opt->force_stop_child = NULL;
opt->local_opt = NULL;
opt->stochastic_population = 0;
opt->vector_storage = 0;
opt->dx = NULL;
opt->work = NULL;
if (n > 0) {
opt->lb = (double *) malloc(sizeof(double) * (n));
if (!opt->lb) goto oom;
opt->ub = (double *) malloc(sizeof(double) * (n));
if (!opt->ub) goto oom;
opt->xtol_abs = (double *) malloc(sizeof(double) * (n));
if (!opt->xtol_abs) goto oom;
nlopt_set_lower_bounds1(opt, -HUGE_VAL);
nlopt_set_upper_bounds1(opt, +HUGE_VAL);
nlopt_set_xtol_abs1(opt, 0.0);
}
}
return opt;
oom:
nlopt_destroy(opt);
return NULL;
}
nlopt_opt make_opt(const mxArray *opts, unsigned n)
{
nlopt_opt opt = NULL, local_opt = NULL;
nlopt_algorithm algorithm;
double *tmp = NULL;
unsigned i;
algorithm = (nlopt_algorithm)
struct_val_default(opts, "algorithm", NLOPT_NUM_ALGORITHMS);
CHECK1(((int)algorithm) >= 0 && algorithm < NLOPT_NUM_ALGORITHMS,
"invalid opt.algorithm");
tmp = (double *) mxCalloc(n, sizeof(double));
opt = nlopt_create(algorithm, n);
CHECK1(opt, "nlopt: out of memory");
nlopt_set_lower_bounds(opt, struct_arrval(opts, "lower_bounds", n,
fill(tmp, n, -HUGE_VAL)));
nlopt_set_upper_bounds(opt, struct_arrval(opts, "upper_bounds", n,
fill(tmp, n, +HUGE_VAL)));
nlopt_set_stopval(opt, struct_val_default(opts, "stopval", -HUGE_VAL));
nlopt_set_ftol_rel(opt, struct_val_default(opts, "ftol_rel", 0.0));
nlopt_set_ftol_abs(opt, struct_val_default(opts, "ftol_abs", 0.0));
nlopt_set_xtol_rel(opt, struct_val_default(opts, "xtol_rel", 0.0));
nlopt_set_xtol_abs(opt, struct_arrval(opts, "xtol_abs", n,
fill(tmp, n, 0.0)));
nlopt_set_maxeval(opt, struct_val_default(opts, "maxeval", 0.0) < 0 ?
0 : struct_val_default(opts, "maxeval", 0.0));
nlopt_set_maxtime(opt, struct_val_default(opts, "maxtime", 0.0));
nlopt_set_population(opt, struct_val_default(opts, "population", 0));
nlopt_set_vector_storage(opt, struct_val_default(opts, "vector_storage", 0));
if (struct_arrval(opts, "initial_step", n, NULL))
nlopt_set_initial_step(opt,
struct_arrval(opts, "initial_step", n, NULL));
if (mxGetField(opts, 0, "local_optimizer")) {
const mxArray *local_opts = mxGetField(opts, 0, "local_optimizer");
CHECK1(mxIsStruct(local_opts),
"opt.local_optimizer must be a structure");
CHECK1(local_opt = make_opt(local_opts, n),
"error initializing local optimizer");
nlopt_set_local_optimizer(opt, local_opt);
nlopt_destroy(local_opt); local_opt = NULL;
}
mxFree(tmp);
return opt;
}
Eigen::VectorXd TargetTrackingController::getControl(const EKF *ekf, const MultiAgentMotionModel *motionModel, const std::vector<const SensorModel*> &sensorModel, double *f) const {
Evaluator evaluator(ekf, motionModel, sensorModel, params);
Eigen::VectorXd p = Eigen::VectorXd::Zero(motionModel->getControlDim());
Eigen::VectorXd lowerBound = Eigen::VectorXd::Constant(motionModel->getControlDim(), params("multi_rotor_control/controlMin").toDouble());
Eigen::VectorXd upperBound = Eigen::VectorXd::Constant(motionModel->getControlDim(), params("multi_rotor_control/controlMax").toDouble());
nlopt_opt opt = nlopt_create(NLOPT_LN_COBYLA, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LN_BOBYQA, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LN_NEWUOA_BOUND, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LN_PRAXIS, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LN_NELDERMEAD, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LN_SBPLX, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_GN_ORIG_DIRECT, p.size()); // failed
// nlopt_opt opt = nlopt_create(NLOPT_GN_ORIG_DIRECT_L, p.size()); // very good: p 0.0118546 -6.27225e-05 6.27225e-05 -2.09075e-05 2.09075e-05 -8.51788e-06 -2.09075e-05 10
// nlopt_opt opt = nlopt_create(NLOPT_GN_ISRES, p.size()); // rather bad
// nlopt_opt opt = nlopt_create(NLOPT_GN_CRS2_LM, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LD_MMA, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LD_CCSAQ, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LD_SLSQP, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LD_LBFGS, p.size());
// nlopt_opt opt = nlopt_create(NLOPT_LD_TNEWTON_PRECOND, p.size()); // bad
// nlopt_opt opt = nlopt_create(NLOPT_LD_TNEWTON_PRECOND_RESTART, p.size()); // bad
// nlopt_opt opt = nlopt_create(NLOPT_LD_VAR2, p.size());
nlopt_set_min_objective(opt, f_evaluate, &evaluator);
nlopt_set_lower_bounds(opt, lowerBound.data());
nlopt_set_upper_bounds(opt, upperBound.data());
nlopt_set_ftol_abs(opt, 1E-6);
nlopt_set_xtol_rel(opt, 1E-3);
nlopt_set_maxeval(opt, 1E8);
nlopt_set_maxtime(opt, 7200);
double pa[p.size()];
memcpy(pa, p.data(), p.size()*sizeof(double));
double cost = 0;
// std::string tmp; std::cerr << "Press enter to start optimization\n"; std::getline(std::cin, tmp);
nlopt_result ret = nlopt_optimize(opt, pa, &cost);
Eigen::VectorXd p_res = Eigen::Map<Eigen::VectorXd>(pa, p.size());
if (f)
*f = cost;
std::cerr << "\nInitial guess:\n";
std::cerr << " p " << p.transpose() << "\n";
std::cerr << " value " << evaluator.evaluate(p) << "\n";
std::cerr << "Optimization result (return code " << ret << "):\n";
std::cerr << " p " << p_res.transpose() << "\n";
std::cerr << " value " << evaluator.evaluate(p_res) << "\n";
nlopt_destroy(opt);
return p_res;
}
double Optimize_Torsion_Parameters(int Idx_Soft_Tor)
{
double lb[N_TOR_PARA] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -100.0 }; /* lower bounds */
double ub[N_TOR_PARA] = { 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 100.0 }; /* lower bounds */
double Phase[32][5]={{0, 0, 0, 0, 0}, {0, 0, 0, 0, PI}, {0, 0, 0, PI, 0}, {0, 0, 0, PI, PI}, {0, 0, PI, 0, 0}, {0, 0, PI, 0, PI}, {0, 0, PI, PI, 0}, {0, 0, PI, PI, PI}, {0, PI, 0, 0, 0}, {0, PI, 0, 0, PI},
{0, PI, 0, PI, 0}, {0, PI, 0, PI, PI}, {0, PI, PI, 0, 0}, {0, PI, PI, 0, PI}, {0, PI, PI, PI, 0}, {0, PI, PI, PI, PI}, {PI, 0, 0, 0, 0}, {PI, 0, 0, 0, PI}, {PI, 0, 0, PI, 0}, {PI, 0, 0, PI, PI},
{PI, 0, PI, 0, 0}, {PI, 0, PI, 0, PI}, {PI, 0, PI, PI, 0}, {PI, 0, PI, PI, PI}, {PI, PI, 0, 0, 0}, {PI, PI, 0, 0, PI}, {PI, PI, 0, PI, 0}, {PI, PI, 0, PI, PI}, {PI, PI, PI, 0, 0}, {PI, PI, PI, 0, PI},
{PI, PI, PI, PI, 0}, {PI, PI, PI, PI, PI}};
nlopt_opt opt;
double Chi_SQ;
int i, j, Idx_Phi;
Chi_SQ_Min = 1.0E100;
opt = nlopt_create(NLOPT_LD_LBFGS, N_TOR_PARA);
nlopt_set_lower_bounds(opt, lb);
nlopt_set_upper_bounds(opt, ub);
nlopt_set_min_objective(opt, Callback_Eval_Gradient, NULL);
nlopt_set_xtol_rel(opt, 1e-8);
iseed = time(NULL);
ActiveRun = 0;
Chi_SQ_Min_Local[0] = 1.0E200;
FailCount = Iteration = 0;
Idx_Phi = IdxDihSelect[Idx_Soft_Tor];
Para_Tor[10] = 0.0;
for(i=0; i<N_TOR_PARA; i++) {
IsPara_Fixed[i] = 1;
}
IsPara_Fixed[N_TOR_PARA-1] = 0; // only optimize the last parameter
if (nlopt_optimize(opt, Para_Tor, &Chi_SQ) < 0) {
printf("nlopt failed!\n");
}
else {
printf("Chi_SQ_min = %lf Chi_SQ = %lf\n", Chi_SQ_Min, Chi_SQ);
}
memcpy(Para_Tor, Para_Best, sizeof(double)*N_TOR_PARA);
CalObjectiveFunction_Tor(Para_Tor);
nlopt_destroy(opt);
return Chi_SQ_Min;
}
int call_nlopt(nlopt_algorithm alg, double ftol, double *step_size, double *params, unsigned np, double (*func) (unsigned,const double*,double*,void*),double *lower, double *upper) {
nlopt_opt opt;
double minf; /* the minimum objective value, upon return */
int retval;
int i;
opt = nlopt_create(alg,np);
nlopt_set_lower_bounds(opt,lower);
nlopt_set_upper_bounds(opt,upper);
nlopt_set_min_objective(opt,func,NULL);
nlopt_set_ftol_abs(opt,ftol);
nlopt_set_initial_step(opt,step_size);
retval = nlopt_optimize(opt, params, &minf) ;
nlopt_destroy(opt);
return retval;
}
double Do_Geometry_Optimization(CMol *pMol)
{
int i, nAtom, nDim, iPos, Return_Opt;
double x[MAX_NUM_ATOM*3], x_Ini[MAX_NUM_ATOM], y_Ini[MAX_NUM_ATOM], z_Ini[MAX_NUM_ATOM], E_min=1.0E100;
// pMol->Restrain_All_Torsions(1);
nAtom = pMol->nAtom;
nDim = 3*nAtom;
// for a large molecule with many soft dihedrals, we prefer the optimizer in nlopt since it is around 8 times faster
memcpy(x_Ini, pMol->x, sizeof(double)*nAtom); // backup the structure
memcpy(y_Ini, pMol->y, sizeof(double)*nAtom);
memcpy(z_Ini, pMol->z, sizeof(double)*nAtom);
opt_Geo = nlopt_create(NLOPT_LD_LBFGS, nDim); // fast for non-polarizable model. Not applicable for drude model
nlopt_set_min_objective(opt_Geo, func_Geo_Optimization, pMol);
nlopt_set_ftol_rel(opt_Geo, 5E-12);
for(i=0; i<nAtom; i++) { // to set up the initial parameters
iPos = 3*i;
x[iPos ] = pMol->x[i];
x[iPos+1] = pMol->y[i];
x[iPos+2] = pMol->z[i];
}
Iter_Geo_Opt = 0;
Return_Opt = nlopt_optimize(opt_Geo, x, &E_min);
nlopt_destroy(opt_Geo);
if( (Return_Opt == NLOPT_FTOL_REACHED) || (Return_Opt == NLOPT_SUCCESS) ) { // success in optimization
pMol->Restrain_All_Torsions(0);
return (pMol->Cal_E(0));
}
else { // try FullGeometryOptimization_LBFGS()
memcpy(pMol->x, x_Ini, sizeof(double)*nAtom); // restore the structure
memcpy(pMol->y, y_Ini, sizeof(double)*nAtom);
memcpy(pMol->z, z_Ini, sizeof(double)*nAtom);
pMol->FullGeometryOptimization_LBFGS_step(0);
pMol->Restrain_All_Torsions(0);
E_min = pMol->Cal_E(0);
return E_min;
}
}
/*
* NLOPT optimization routine for table tennis traj gen
*
*/
void nlopt_optim_poly_run(double *x, double *params) {
static double tol[EQ_CONSTR_DIM];
static double lb[OPTIM_DIM]; /* lower bounds */
static double ub[OPTIM_DIM]; /* upper bounds */
set_bounds(lb,ub);
const_vec(EQ_CONSTR_DIM,1e-2,tol); /* set tolerances equal to second argument */
nlopt_opt opt;
opt = nlopt_create(NLOPT_LN_COBYLA, OPTIM_DIM); /* LN = does not require gradients */
//nlopt_set_xtol_rel(opt, 1e-2);
//opt = nlopt_create(NLOPT_AUGLAG, OPTIM_DIM); /* algorithm and dimensionality */
//nlopt_set_local_optimizer(opt, opt);
nlopt_set_lower_bounds(opt, lb);
nlopt_set_upper_bounds(opt, ub);
nlopt_set_min_objective(opt, costfunc, params);
nlopt_add_inequality_mconstraint(opt, INEQ_CONSTR_DIM, joint_limits_ineq_constr, params, tol);
nlopt_add_equality_mconstraint(opt, EQ_CONSTR_DIM, kinematics_eq_constr, params, tol);
nlopt_set_xtol_rel(opt, 1e-2);
//int maxeval = 20000;
//nlopt_set_maxeval(opt, maxeval);
//double maxtime = 0.001;
//nlopt_set_maxtime(opt, maxtime);
//init_soln_to_rest_posture(x,params); //parameters are the initial joint positions q0
double initTime = get_time();
double minf; /* the minimum objective value, upon return */
if (nlopt_optimize(opt, x, &minf) < 0) {
printf("NLOPT failed!\n");
}
else {
//nlopt_example_run();
printf("NLOPT took %f ms\n", (get_time() - initTime)/1e3);
printf("Found minimum at f = %0.10g\n", minf);
test_optim(x,params);
}
nlopt_destroy(opt);
}
/* like nlopt_destroy, but also frees elimdim_data */
static void elimdim_destroy(nlopt_opt opt)
{
unsigned i;
if (!opt) return;
free(((elimdim_data*) opt->f_data)->x);
free(((elimdim_data*) opt->f_data)->grad);
free(opt->f_data); opt->f_data = NULL;
for (i = 0; i < opt->m; ++i) {
free(opt->fc[i].f_data);
opt->fc[i].f_data = NULL;
}
for (i = 0; i < opt->p; ++i) {
free(opt->h[i].f_data);
opt->h[i].f_data = NULL;
}
nlopt_destroy(opt);
}
double NLfit::run_method(vector<realt>* best_a)
{
if (opt_ != NULL && na_ != (int) nlopt_get_dimension(opt_)) {
nlopt_destroy(opt_);
opt_ = NULL;
}
if (opt_ == NULL) {
opt_ = nlopt_create(algorithm_, na_);
nlopt_set_min_objective(opt_, calculate_for_nlopt, this);
}
// this is also handled in Fit::common_termination_criteria()
nlopt_set_maxtime(opt_, F_->get_settings()->max_fitting_time);
nlopt_set_maxeval(opt_, max_eval() - 1); // save 1 eval for final calc.
nlopt_set_ftol_rel(opt_, F_->get_settings()->ftol_rel);
nlopt_set_xtol_rel(opt_, F_->get_settings()->xtol_rel);
double *lb = new double[na_];
double *ub = new double[na_];
for (int i = 0; i < na_; ++i) {
const RealRange& d = F_->mgr.get_variable(i)->domain;
lb[i] = d.lo;
ub[i] = d.hi;
}
nlopt_set_lower_bounds(opt_, lb);
nlopt_set_upper_bounds(opt_, ub);
delete [] lb;
delete [] ub;
double opt_f;
double *a = new double[na_];
for (int i = 0; i < na_; ++i)
a[i] = a_orig_[i];
nlopt_result r = nlopt_optimize(opt_, a, &opt_f);
F_->msg("NLopt says: " + S(nlresult_to_string(r)));
best_a->assign(a, a+na_);
delete [] a;
return opt_f;
}
nlopt_result
NLOPT_STDCALL nlopt_set_local_optimizer(nlopt_opt opt,
const nlopt_opt local_opt)
{
if (opt) {
if (local_opt && local_opt->n != opt->n) return NLOPT_INVALID_ARGS;
nlopt_destroy(opt->local_opt);
opt->local_opt = nlopt_copy(local_opt);
if (local_opt) {
if (!opt->local_opt) return NLOPT_OUT_OF_MEMORY;
nlopt_set_lower_bounds(opt->local_opt, opt->lb);
nlopt_set_upper_bounds(opt->local_opt, opt->ub);
nlopt_remove_inequality_constraints(opt->local_opt);
nlopt_remove_equality_constraints(opt->local_opt);
nlopt_set_min_objective(opt->local_opt, NULL, NULL);
nlopt_set_munge(opt->local_opt, NULL, NULL);
opt->local_opt->force_stop = 0;
}
return NLOPT_SUCCESS;
}
return NLOPT_INVALID_ARGS;
}
void calculateSigma2() {
// use non linear optimization to calculate sigma2
nlopt_opt opt;
const int nParam = sigma2.size();
std::vector<double> lb(nParam, 1e-10);
opt = nlopt_create(NLOPT_LN_COBYLA, nParam);
nlopt_set_lower_bounds(opt, lb.data());
nlopt_set_min_objective(opt, goalFunction, this);
nlopt_set_xtol_rel(opt, 1e-4);
double minf; /* the minimum objective value, upon return */
int retCode = nlopt_optimize(opt, sigma2.data(), &minf);
if (retCode < 0) {
#ifdef DEBUG
printf("nlopt failed [ %d ]!\n", retCode);
#endif
} else {
#ifdef DEBUG
printf("found minimum at %g\n", minf);
#endif
}
nlopt_destroy(opt);
}
void
FitOrientation(
const int NrOfFiles,
const int nLayers,
const double ExcludePoleAngle,
double Lsd[nLayers],
const long long int SizeObsSpots,
double TiltsOrig[3],
const double OmegaStart,
const double OmegaStep,
const double px,
double ybc[nLayers],
double zbc[nLayers],
const double gs,
double SpotsInfo[200][9],
int nSpots,
double OmegaRanges[MAX_N_OMEGA_RANGES][2],
const int NoOfOmegaRanges,
double BoxSizes[MAX_N_OMEGA_RANGES][4],
double P0[nLayers][3],
const int NrPixelsGrid,
int *ObsSpotsInfo,
double tol,
double hkls[5000][4],
double Thetas[5000],
int n_hkls,
double **SpotsOut,
double *LsdFit,
double *TiltsFit,
double **BCsFit,
double tolLsd,
double tolLsdRel,
double tolTilts,
double tolBCsa,
double tolBCsb)
{
unsigned n;
long int i,j;
n = 3+(nLayers*3)+(nSpots*3);
double x[n],xl[n],xu[n];
for (i=0;i<n;i++){
x[i] = 0;
xl[i] = 0;
xu[i] = 0;
}
int count = 0;
for (i=0;i<3;i++)
{
x[i] = TiltsOrig[count];
xl[i] = x[i] - tolTilts;
xu[i] = x[i] + tolTilts;
count++;
}
count = 0;
x[3] = Lsd[0];
xl[3] = x[3] - tolLsd;
xu[3] = x[3] + tolLsd;
count++;
for (i=4;i<nLayers+3;i++)
{
x[i] = Lsd[count] - Lsd[count-1];
xl[i] = x[i] - tolLsdRel;
xu[i] = x[i] + tolLsdRel;
count++;
}
count = 0;
for (i=3+nLayers;i<3+(nLayers*2);i++)
{
x[i] = ybc[count];
x[i+nLayers] = zbc[count];
xl[i] = x[i] - tolBCsa;
xl[i+nLayers] = x[i+nLayers] - tolBCsb;
xu[i] = x[i] + tolBCsa;
xu[i+nLayers] = x[i+nLayers] + tolBCsb;
count++;
}
count = 0;
int ps;
for( i=0; i<nSpots; i++)
{
for (j=0;j<3;j++){
ps = i*3+j+3+(nLayers*3);
x[ps] = SpotsInfo[i][6+j];
xl[ps] = x[ps] - (tol*M_PI/180);
xu[ps] = x[ps] + (tol*M_PI/180);
}
}
//for (i=0;i<n;i++) printf("%f %f %f\n",x[i],xl[i],xu[i]);
struct my_func_data f_data;
f_data.NrOfFiles = NrOfFiles;
f_data.nLayers = nLayers;
f_data.n_hkls = n_hkls;
for (i=0;i<5000;i++){
f_data.hkls[i][0] = hkls[i][0];
f_data.hkls[i][1] = hkls[i][1];
f_data.hkls[i][2] = hkls[i][2];
f_data.hkls[i][3] = hkls[i][3];
f_data.Thetas[i] = Thetas[i];
}
f_data.ExcludePoleAngle = ExcludePoleAngle;
f_data.SizeObsSpots = SizeObsSpots;
f_data.P0 = allocMatrixF(nLayers,3);
for (i=0;i<3;i++){
for (j=0;j<nSpots;j++){
f_data.XGrain[j][i] = SpotsInfo[j][2*i];
f_data.YGrain[j][i] = SpotsInfo[j][2*i+1];
}
for (j=0;j<nLayers;j++){
f_data.P0[j][i] = P0[j][i];
}
}
for (i=0;i<MAX_N_OMEGA_RANGES;i++){
for (j=0;j<2;j++){
f_data.OmegaRanges[i][j] = OmegaRanges[i][j];
}
for (j=0;j<4;j++){
f_data.BoxSizes[i][j] = BoxSizes[i][j];
}
}
f_data.ObsSpotsInfo = &ObsSpotsInfo[0];
f_data.OmegaStart = OmegaStart;
f_data.OmegaStep = OmegaStep;
f_data.px = px;
f_data.gs = gs;
f_data.nSpots = nSpots;
f_data.NoOfOmegaRanges = NoOfOmegaRanges;
f_data.NrPixelsGrid = NrPixelsGrid;
struct my_func_data *f_datat;
f_datat = &f_data;
void* trp = (struct my_func_data *) f_datat;
double tole = 1e-3;
nlopt_opt opt;
opt = nlopt_create(NLOPT_LN_NELDERMEAD, n);
nlopt_set_lower_bounds(opt, xl);
nlopt_set_upper_bounds(opt, xu);
nlopt_set_min_objective(opt, problem_function, trp);
double minf=1;
nlopt_optimize(opt, x, &minf);
nlopt_destroy(opt);
TiltsFit[0] = x[0];
TiltsFit[1] = x[1];
TiltsFit[2] = x[2];
LsdFit[0] = x[3];
for (i=1;i<nLayers;i++){
LsdFit[i] = LsdFit[i-1] + x[3+i];
}
for (i=0;i<nLayers;i++){
BCsFit[i][0] = x[3+nLayers+i];
BCsFit[i][1] = x[3+nLayers+nLayers+i];
}
for (i=0;i<nSpots;i++){
for (j=0;j<3;j++){
ps = i*3+j+3+(nLayers*3);
SpotsOut[i][j] = x[ps];
}
SpotsOut[i][3] = IndividualResults[i];
}
}
nlopt_result
NLOPT_STDCALL nlopt_minimize_econstrained(
nlopt_algorithm algorithm,
int n, nlopt_func_old f, void *f_data,
int m, nlopt_func_old fc, void *fc_data_, ptrdiff_t fc_datum_size,
int p, nlopt_func_old h, void *h_data_, ptrdiff_t h_datum_size,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf, /* out: minimum */
double minf_max, double ftol_rel, double ftol_abs,
double xtol_rel, const double *xtol_abs,
double htol_rel, double htol_abs,
int maxeval, double maxtime)
{
char *fc_data = (char *) fc_data_;
char *h_data = (char *) h_data_;
nlopt_opt opt;
nlopt_result ret;
int i;
if (n < 0 || m < 0 || p < 0) return NLOPT_INVALID_ARGS;
opt = nlopt_create(algorithm, (unsigned) n);
if (!opt) return NLOPT_INVALID_ARGS;
ret = nlopt_set_min_objective(opt, (nlopt_func) f, f_data);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
for (i = 0; i < m; ++i) {
ret = nlopt_add_inequality_constraint(opt, (nlopt_func) fc,
fc_data + i*fc_datum_size,
0.0);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
}
(void) htol_rel; /* unused */
for (i = 0; i < p; ++i) {
ret = nlopt_add_equality_constraint(opt, (nlopt_func) h,
h_data + i*h_datum_size,
htol_abs);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
}
ret = nlopt_set_lower_bounds(opt, lb);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_upper_bounds(opt, ub);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_stopval(opt, minf_max);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_ftol_rel(opt, ftol_rel);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_ftol_abs(opt, ftol_abs);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_xtol_rel(opt, xtol_rel);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_xtol_abs(opt, xtol_abs);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_maxeval(opt, maxeval);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_set_maxtime(opt, maxtime);
if (ret != NLOPT_SUCCESS) { nlopt_destroy(opt); return ret; }
ret = nlopt_optimize(opt, x, minf);
nlopt_destroy(opt);
return ret;
}
nlopt_result ccsa_quadratic_minimize(
unsigned n, nlopt_func f, void *f_data,
unsigned m, nlopt_constraint *fc,
nlopt_precond pre,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
nlopt_opt dual_opt)
{
nlopt_result ret = NLOPT_SUCCESS;
double *xcur, rho, *sigma, *dfdx, *dfdx_cur, *xprev, *xprevprev, fcur;
double *dfcdx, *dfcdx_cur;
double *fcval, *fcval_cur, *rhoc, *gcval, *y, *dual_lb, *dual_ub;
double *pre_lb, *pre_ub;
unsigned i, ifc, j, k = 0;
dual_data dd;
int feasible;
double infeasibility;
unsigned mfc;
unsigned no_precond;
nlopt_opt pre_opt = NULL;
m = nlopt_count_constraints(mfc = m, fc);
if (nlopt_get_dimension(dual_opt) != m) return NLOPT_INVALID_ARGS;
sigma = (double *) malloc(sizeof(double) * (6*n + 2*m*n + m*7));
if (!sigma) return NLOPT_OUT_OF_MEMORY;
dfdx = sigma + n;
dfdx_cur = dfdx + n;
xcur = dfdx_cur + n;
xprev = xcur + n;
xprevprev = xprev + n;
fcval = xprevprev + n;
fcval_cur = fcval + m;
rhoc = fcval_cur + m;
gcval = rhoc + m;
dual_lb = gcval + m;
dual_ub = dual_lb + m;
y = dual_ub + m;
dfcdx = y + m;
dfcdx_cur = dfcdx + m*n;
dd.n = n;
dd.x = x;
dd.lb = lb;
dd.ub = ub;
dd.sigma = sigma;
dd.dfdx = dfdx;
dd.dfcdx = dfcdx;
dd.fcval = fcval;
dd.rhoc = rhoc;
dd.xcur = xcur;
dd.gcval = gcval;
dd.pre = pre; dd.pre_data = f_data;
dd.prec = NULL; dd.prec_data = NULL;
dd.scratch = NULL;
if (m) {
dd.prec = (nlopt_precond *) malloc(sizeof(nlopt_precond) * m);
dd.prec_data = (void **) malloc(sizeof(void *) * m);
if (!dd.prec || !dd.prec_data) {
ret = NLOPT_OUT_OF_MEMORY;
goto done;
}
for (i = ifc = 0; ifc < mfc; ++ifc) {
unsigned inext = i + fc[ifc].m;
for (; i < inext; ++i) {
dd.prec[i] = fc[ifc].pre;
dd.prec_data[i] = fc[ifc].f_data;
}
}
}
no_precond = pre == NULL;
if (dd.prec)
for (i = 0; i < m; ++i)
no_precond = no_precond && dd.prec[i] == NULL;
if (!no_precond) {
dd.scratch = (double*) malloc(sizeof(double) * (4*n));
if (!dd.scratch) {
free(sigma);
return NLOPT_OUT_OF_MEMORY;
}
pre_lb = dd.scratch + 2*n;
pre_ub = pre_lb + n;
pre_opt = nlopt_create(nlopt_get_algorithm(dual_opt), n);
if (!pre_opt) { ret = NLOPT_FAILURE; goto done; }
ret = nlopt_set_min_objective(pre_opt, g0, &dd);
if (ret < 0) goto done;
ret = nlopt_add_inequality_mconstraint(pre_opt, m, gi, &dd, NULL);
if (ret < 0) goto done;
ret = nlopt_set_ftol_rel(pre_opt, nlopt_get_ftol_rel(dual_opt));
if (ret < 0) goto done;
ret = nlopt_set_ftol_abs(pre_opt, nlopt_get_ftol_abs(dual_opt));
if (ret < 0) goto done;
ret = nlopt_set_maxeval(pre_opt, nlopt_get_maxeval(dual_opt));
if (ret < 0) goto done;
}
for (j = 0; j < n; ++j) {
if (nlopt_isinf(ub[j]) || nlopt_isinf(lb[j]))
sigma[j] = 1.0; /* arbitrary default */
else
sigma[j] = 0.5 * (ub[j] - lb[j]);
}
rho = 1.0;
for (i = 0; i < m; ++i) {
rhoc[i] = 1.0;
dual_lb[i] = y[i] = 0.0;
dual_ub[i] = HUGE_VAL;
}
dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
stop->nevals++;
memcpy(xcur, x, sizeof(double) * n);
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
feasible = 1; infeasibility = 0;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval + i, dfcdx + i*n,
fc + ifc, n, x);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = 0; i < m; ++i) {
feasible = feasible && fcval[i] <= 0;
if (fcval[i] > infeasibility) infeasibility = fcval[i];
}
/* For non-feasible initial points, set a finite (large)
upper-bound on the dual variables. What this means is that,
if no feasible solution is found from the dual problem, it
will minimize the dual objective with the unfeasible
constraint weighted by 1e40 -- basically, minimizing the
unfeasible constraint until it becomes feasible or until we at
least obtain a step towards a feasible point.
Svanberg suggested a different approach in his 1987 paper, basically
introducing additional penalty variables for unfeasible constraints,
but this is easier to implement and at least as efficient. */
if (!feasible)
for (i = 0; i < m; ++i) dual_ub[i] = 1e40;
nlopt_set_min_objective(dual_opt, dual_func, &dd);
nlopt_set_lower_bounds(dual_opt, dual_lb);
nlopt_set_upper_bounds(dual_opt, dual_ub);
nlopt_set_stopval(dual_opt, -HUGE_VAL);
nlopt_remove_inequality_constraints(dual_opt);
nlopt_remove_equality_constraints(dual_opt);
while (1) { /* outer iterations */
double fprev = fcur;
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (++k > 1) memcpy(xprevprev, xprev, sizeof(double) * n);
memcpy(xprev, xcur, sizeof(double) * n);
while (1) { /* inner iterations */
double min_dual, infeasibility_cur;
int feasible_cur, inner_done;
unsigned save_verbose;
nlopt_result reti;
if (no_precond) {
/* solve dual problem */
dd.rho = rho; dd.count = 0;
save_verbose = ccsa_verbose;
ccsa_verbose = 0; /* no recursive verbosity */
reti = nlopt_optimize_limited(dual_opt, y, &min_dual,
0,
stop->maxtime
- (nlopt_seconds()
- stop->start));
ccsa_verbose = save_verbose;
if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
ret = reti;
goto done;
}
dual_func(m, y, NULL, &dd); /* evaluate final xcur etc. */
}
else {
double pre_min;
for (j = 0; j < n; ++j) {
pre_lb[j] = MAX(lb[j], x[j] - sigma[j]);
pre_ub[j] = MIN(ub[j], x[j] + sigma[j]);
xcur[j] = x[j];
}
nlopt_set_lower_bounds(pre_opt, pre_lb);
nlopt_set_upper_bounds(pre_opt, pre_ub);
dd.rho = rho; dd.count = 0;
save_verbose = ccsa_verbose;
ccsa_verbose = 0; /* no recursive verbosity */
reti = nlopt_optimize_limited(pre_opt, xcur, &pre_min,
0, stop->maxtime
- (nlopt_seconds()
- stop->start));
ccsa_verbose = save_verbose;
if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
ret = reti;
goto done;
}
/* evaluate final xcur etc */
dd.gval = g0(n, xcur, NULL, &dd);
gi(m, dd.gcval, n, xcur, NULL, &dd);
}
if (ccsa_verbose) {
printf("CCSA dual converged in %d iters to g=%g:\n",
dd.count, dd.gval);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA y[%d]=%g, gc[%d]=%g\n",
i, y[i], i, dd.gcval[i]);
}
fcur = f(n, xcur, dfdx_cur, f_data);
stop->nevals++;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
feasible_cur = 1; infeasibility_cur = 0;
inner_done = dd.gval >= fcur;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval_cur + i, dfcdx_cur + i*n,
fc + ifc, n, xcur);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = ifc = 0; ifc < mfc; ++ifc) {
unsigned i0 = i, inext = i + fc[ifc].m;
for (; i < inext; ++i) {
feasible_cur = feasible_cur
&& fcval_cur[i] <= fc[ifc].tol[i-i0];
inner_done = inner_done &&
(dd.gcval[i] >= fcval_cur[i]);
if (fcval_cur[i] > infeasibility_cur)
infeasibility_cur = fcval_cur[i];
}
}
if ((fcur < *minf && (inner_done || feasible_cur || !feasible))
|| (!feasible && infeasibility_cur < infeasibility)) {
if (ccsa_verbose && !feasible_cur)
printf("CCSA - using infeasible point?\n");
dd.fval = *minf = fcur;
infeasibility = infeasibility_cur;
memcpy(fcval, fcval_cur, sizeof(double)*m);
memcpy(x, xcur, sizeof(double)*n);
memcpy(dfdx, dfdx_cur, sizeof(double)*n);
memcpy(dfcdx, dfcdx_cur, sizeof(double)*n*m);
/* once we have reached a feasible solution, the
algorithm should never make the solution infeasible
again (if inner_done), although the constraints may
be violated slightly by rounding errors etc. so we
must be a little careful about checking feasibility */
if (infeasibility_cur == 0) {
if (!feasible) { /* reset upper bounds to infin. */
for (i = 0; i < m; ++i) dual_ub[i] = HUGE_VAL;
nlopt_set_upper_bounds(dual_opt, dual_ub);
}
feasible = 1;
}
}
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (inner_done) break;
if (fcur > dd.gval)
rho = MIN(10*rho, 1.1 * (rho + (fcur-dd.gval) / dd.wval));
for (i = 0; i < m; ++i)
if (fcval_cur[i] > dd.gcval[i])
rhoc[i] =
MIN(10*rhoc[i],
1.1 * (rhoc[i] + (fcval_cur[i]-dd.gcval[i])
/ dd.wval));
if (ccsa_verbose)
printf("CCSA inner iteration: rho -> %g\n", rho);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA rhoc[%d] -> %g\n", i,rhoc[i]);
}
if (nlopt_stop_ftol(stop, fcur, fprev))
ret = NLOPT_FTOL_REACHED;
if (nlopt_stop_x(stop, xcur, xprev))
ret = NLOPT_XTOL_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
/* update rho and sigma for iteration k+1 */
rho = MAX(0.1 * rho, CCSA_RHOMIN);
if (ccsa_verbose)
printf("CCSA outer iteration: rho -> %g\n", rho);
for (i = 0; i < m; ++i)
rhoc[i] = MAX(0.1 * rhoc[i], CCSA_RHOMIN);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA rhoc[%d] -> %g\n", i, rhoc[i]);
if (k > 1) {
for (j = 0; j < n; ++j) {
double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
double gam = dx2 < 0 ? 0.7 : (dx2 > 0 ? 1.2 : 1);
sigma[j] *= gam;
if (!nlopt_isinf(ub[j]) && !nlopt_isinf(lb[j])) {
sigma[j] = MIN(sigma[j], 10*(ub[j]-lb[j]));
/* use a smaller lower bound than Svanberg's
0.01*(ub-lb), which seems unnecessarily large */
sigma[j] = MAX(sigma[j], 1e-8*(ub[j]-lb[j]));
}
}
for (j = 0; j < MIN(ccsa_verbose, n); ++j)
printf(" CCSA sigma[%d] -> %g\n",
j, sigma[j]);
}
}
done:
nlopt_destroy(pre_opt);
if (dd.scratch) free(dd.scratch);
if (m) {
free(dd.prec_data);
free(dd.prec);
}
free(sigma);
return ret;
}
double Optimize_Torsion_Parameters(void)
{
double lb[N_PARA_MAX], ub[N_PARA_MAX];
double Chi_SQ;
int i, j, Pos;
n_Para = 10*n_Phi + 1;
memset(Is_Para_Fixed, 0, sizeof(int)*n_Para);
// memset(lb, 0, sizeof(double)*n_Para);
lb[n_Phi*10] = -HUGE_VAL;
for(i=0; i<n_Phi; i++) {
Pos = 10*i;
for(j=0; j<10; j+=2) { // ten parameters
lb[Pos+j] = -15.0;
ub[Pos+j] = 15.0;
}
for(j=1; j<10; j+=2) { // ten parameters
lb[Pos+j] = -M_PI;
ub[Pos+j] = +M_PI;
}
}
ub[n_Phi*10] = HUGE_VAL;
opt = nlopt_create(NLOPT_LN_COBYLA, n_Para);
nlopt_set_lower_bounds(opt, lb);
nlopt_set_upper_bounds(opt, ub);
nlopt_set_min_objective(opt, Callback_Eval_Gradient, NULL);
nlopt_set_xtol_rel(opt, 1e-6);
Collect_Torsion_Parameters();
Assign_Torsion_Parameters();
Cal_E_MM_Scaned();
Cal_E_MM_Rotamer();
Para_List[n_Phi*10] = E_Scan_QM_Mean-E_Scan_MM_Mean; // energy shift
E_Shift_0 = fabs(E_Scan_QM_Mean-E_Scan_MM_Mean);
for(i=0; i<n_Phi; i++) {
Pos = 10*i;
for(j=1; j<10; j+=2) { // the phase is fixed
Is_Para_Fixed[Pos+j] = 1;
}
}
Read_Parameters("saved-para.dat");
Chi_SQ_Min = 1.0E100;
memcpy(Para_Best, Para_List, sizeof(double)*n_Para);
Chi_SQ = CalObjectiveFunction(Para_List, 0);
if(ProgID == 0) {
fprintf(fFitting, "Iteration %4d Chi^2 = %.8lf Chi^2(1D) = %.8lf Chi^2(rotamer) = %.8lf\n",
0, Chi_SQ, Chi_SQ_1D, Chi_SQ_Rotamer);
fflush(fFitting);
}
FailCount = 0;
int ret= nlopt_optimize(opt, Para_List, &Chi_SQ);
if (ret < 0) {
printf("nlopt failed! :%d\n", ret);
}
else {
printf("Chi_SQ_min = %lf Chi_SQ = %lf\n", Chi_SQ_Min, Chi_SQ);
}
memcpy(Para_List, Para_Best, sizeof(double)*n_Para);
CalObjectiveFunction(Para_List, 1);
nlopt_destroy(opt);
return Chi_SQ_Min;
}
int CNLopt::run(double (*error_func)(unsigned int nParams, const double* params, double* grad, void* misc))
{
// Create a member function pointer
unsigned int n_data = mWorkerThread->GetDataSize();
mOpt = nlopt_create(mAlgorithm, mNParams);
// xopt = new double [mNParams];
lb = new double [mNParams];
ub = new double [mNParams];
// Copy out the initial values for the parameters:
CModelListPtr model_list = mWorkerThread->GetModelList();
model_list->GetFreeParameters(mParams, mNParams, false);
vector<string> names = model_list->GetFreeParamNames();
vector< pair<double, double> > min_max = model_list->GetFreeParamMinMaxes();
// Init parameter values
for(int i = 0; i < mNParams; i++)
{
lb[i] = min_max[i].first;
ub[i] = min_max[i].second;
// xopt = mParams[i];
}
nlopt_set_lower_bounds(mOpt,lb);
nlopt_set_upper_bounds(mOpt,ub);
nlopt_set_ftol_rel(mOpt, 1e-4); // stopping criterion = when chi2 changes by less than 0.1%
nlopt_set_min_objective(mOpt, error_func, (void*)this);
int major=0, minor=0, bugfix=0;
nlopt_version(&major, &minor, &bugfix);
printf("Starting NLopt version %d.%d.%d\n", major, minor, bugfix);
printf("Algorithm = %s \n", nlopt_algorithm_name(mAlgorithm));
if(mAlgorithm == NLOPT_G_MLSL_LDS) // set local optimizer to be used with a global search
{
printf("Secondary Algorithm = %s \n", nlopt_algorithm_name(mAlgorithmSecondary));
mOptSecondary = nlopt_create(mAlgorithmSecondary, mNParams);
nlopt_set_lower_bounds(mOptSecondary,lb);
nlopt_set_upper_bounds(mOptSecondary,ub);
nlopt_set_ftol_rel(mOptSecondary, 1e-4); // stopping criterion = when chi2 changes by less than 0.1%
nlopt_set_min_objective(mOptSecondary, error_func, (void*)this);
nlopt_set_local_optimizer(mOpt, mOptSecondary);
}
mIsRunning = true;
mEvals = 0;
double minf;
// Call NLopt. Note, the results are saved in mParams upon completion.
nlopt_result result = nlopt_optimize(mOpt, mParams, &minf);
mIsRunning = false;
printresult(mParams, mNParams, n_data, names, minf, result);
delete(lb);
delete(ub);
nlopt_destroy(mOpt);
if(mAlgorithm == NLOPT_G_MLSL_LDS) // also destroy local optimizer
{
nlopt_destroy(mOptSecondary);
}
return mEvals;
}
nlopt_opt NLOPT_STDCALL nlopt_copy(const nlopt_opt opt)
{
nlopt_opt nopt = NULL;
unsigned i;
if (opt) {
nlopt_munge munge;
nopt = (nlopt_opt) malloc(sizeof(struct nlopt_opt_s));
*nopt = *opt;
nopt->lb = nopt->ub = nopt->xtol_abs = NULL;
nopt->fc = nopt->h = NULL;
nopt->m_alloc = nopt->p_alloc = 0;
nopt->local_opt = NULL;
nopt->dx = NULL;
nopt->work = NULL;
opt->force_stop_child = NULL;
munge = nopt->munge_on_copy;
if (munge && nopt->f_data)
if (!(nopt->f_data = munge(nopt->f_data))) goto oom;
if (opt->n > 0) {
nopt->lb = (double *) malloc(sizeof(double) * (opt->n));
if (!opt->lb) goto oom;
nopt->ub = (double *) malloc(sizeof(double) * (opt->n));
if (!opt->ub) goto oom;
nopt->xtol_abs = (double *) malloc(sizeof(double) * (opt->n));
if (!opt->xtol_abs) goto oom;
memcpy(nopt->lb, opt->lb, sizeof(double) * (opt->n));
memcpy(nopt->ub, opt->ub, sizeof(double) * (opt->n));
memcpy(nopt->xtol_abs, opt->xtol_abs, sizeof(double) * (opt->n));
}
if (opt->m) {
nopt->m_alloc = opt->m;
nopt->fc = (nlopt_constraint *) malloc(sizeof(nlopt_constraint)
* (opt->m));
if (!nopt->fc) goto oom;
memcpy(nopt->fc, opt->fc, sizeof(nlopt_constraint) * (opt->m));
for (i = 0; i < opt->m; ++i) nopt->fc[i].tol = NULL;
if (munge)
for (i = 0; i < opt->m; ++i)
if (nopt->fc[i].f_data &&
!(nopt->fc[i].f_data
= munge(nopt->fc[i].f_data)))
goto oom;
for (i = 0; i < opt->m; ++i)
if (opt->fc[i].tol) {
nopt->fc[i].tol = (double *) malloc(sizeof(double)
* nopt->fc[i].m);
if (!nopt->fc[i].tol) goto oom;
memcpy(nopt->fc[i].tol, opt->fc[i].tol,
sizeof(double) * nopt->fc[i].m);
}
}
if (opt->p) {
nopt->p_alloc = opt->p;
nopt->h = (nlopt_constraint *) malloc(sizeof(nlopt_constraint)
* (opt->p));
if (!nopt->h) goto oom;
memcpy(nopt->h, opt->h, sizeof(nlopt_constraint) * (opt->p));
for (i = 0; i < opt->p; ++i) nopt->h[i].tol = NULL;
if (munge)
for (i = 0; i < opt->p; ++i)
if (nopt->h[i].f_data &&
!(nopt->h[i].f_data
= munge(nopt->h[i].f_data)))
goto oom;
for (i = 0; i < opt->p; ++i)
if (opt->h[i].tol) {
nopt->h[i].tol = (double *) malloc(sizeof(double)
* nopt->h[i].m);
if (!nopt->h[i].tol) goto oom;
memcpy(nopt->h[i].tol, opt->h[i].tol,
sizeof(double) * nopt->h[i].m);
}
}
if (opt->local_opt) {
nopt->local_opt = nlopt_copy(opt->local_opt);
if (!nopt->local_opt) goto oom;
}
if (opt->dx) {
nopt->dx = (double *) malloc(sizeof(double) * (opt->n));
if (!nopt->dx) goto oom;
memcpy(nopt->dx, opt->dx, sizeof(double) * (opt->n));
}
}
return nopt;
oom:
nopt->munge_on_destroy = NULL; // better to leak mem than crash
nlopt_destroy(nopt);
return NULL;
}
void
FitOrientation(
const int NrOfFiles,
const int nLayers,
const double ExcludePoleAngle,
double Lsd[nLayers],
const long long int SizeObsSpots,
const double XGrain[3],
const double YGrain[3],
double RotMatTilts[3][3],
const double OmegaStart,
const double OmegaStep,
const double px,
double ybc[nLayers],
double zbc[nLayers],
const double gs,
double OmegaRanges[MAX_N_OMEGA_RANGES][2],
const int NoOfOmegaRanges,
double BoxSizes[MAX_N_OMEGA_RANGES][4],
double P0[nLayers][3],
const int NrPixelsGrid,
int *ObsSpotsInfo,
double EulerIn[3],
double tol,
double *EulerOutA,
double *EulerOutB,
double *EulerOutC,
double *ResultFracOverlap,
double hkls[5000][4],
double Thetas[5000],
int n_hkls)
{
unsigned n;
long int i,j;
n = 3;
double x[n],xl[n],xu[n];
for( i=0; i<n; i++)
{
x[i] = EulerIn[i];
xl[i] = x[i] - (tol*M_PI/180);
xu[i] = x[i] + (tol*M_PI/180);
}
struct my_func_data f_data;
f_data.NrOfFiles = NrOfFiles;
f_data.nLayers = nLayers;
f_data.n_hkls = n_hkls;
for (i=0;i<5000;i++){
f_data.hkls[i][0] = hkls[i][0];
f_data.hkls[i][1] = hkls[i][1];
f_data.hkls[i][2] = hkls[i][2];
f_data.hkls[i][3] = hkls[i][3];
f_data.Thetas[i] = Thetas[i];
}
f_data.ExcludePoleAngle = ExcludePoleAngle;
f_data.SizeObsSpots = SizeObsSpots;
f_data.P0 = allocMatrixF(nLayers,3);
for (i=0;i<3;i++){
f_data.XGrain[i] = XGrain[i];
f_data.YGrain[i] = YGrain[i];
for (j=0;j<nLayers;j++){
f_data.P0[j][i] = P0[j][i];
}
for (j=0;j<3;j++){
f_data.RotMatTilts[i][j] = RotMatTilts[i][j];
}
}
for (i=0;i<MAX_N_OMEGA_RANGES;i++){
for (j=0;j<2;j++){
f_data.OmegaRanges[i][j] = OmegaRanges[i][j];
}
for (j=0;j<4;j++){
f_data.BoxSizes[i][j] = BoxSizes[i][j];
}
}
f_data.ObsSpotsInfo = &ObsSpotsInfo[0];
f_data.Lsd = &Lsd[0];
f_data.ybc = &ybc[0];
f_data.zbc = &zbc[0];
f_data.OmegaStart = OmegaStart;
f_data.OmegaStep = OmegaStep;
f_data.px = px;
f_data.gs = gs;
f_data.NoOfOmegaRanges = NoOfOmegaRanges;
f_data.NrPixelsGrid = NrPixelsGrid;
struct my_func_data *f_datat;
f_datat = &f_data;
void* trp = (struct my_func_data *) f_datat;
double tole = 1e-3;
nlopt_opt opt;
opt = nlopt_create(NLOPT_LN_NELDERMEAD, n);
nlopt_set_lower_bounds(opt, xl);
nlopt_set_upper_bounds(opt, xu);
nlopt_set_min_objective(opt, problem_function, trp);
double minf=1;
nlopt_optimize(opt, x, &minf);
nlopt_destroy(opt);
*ResultFracOverlap = minf;
*EulerOutA = x[0];
*EulerOutB = x[1];
*EulerOutC = x[2];
}
void
FitOrientation(
const int NrOfFiles,
const int nLayers,
const double ExcludePoleAngle,
double Lsd[nLayers],
const long long int SizeObsSpots,
const double XGrain[3],
const double YGrain[3],
double TiltsOrig[3],
const double OmegaStart,
const double OmegaStep,
const double px,
double ybc[nLayers],
double zbc[nLayers],
const double gs,
double OmegaRanges[MAX_N_OMEGA_RANGES][2],
const int NoOfOmegaRanges,
double BoxSizes[MAX_N_OMEGA_RANGES][4],
double P0[nLayers][3],
const int NrPixelsGrid,
int *ObsSpotsInfo,
double EulerIn[3],
double tol,
double *EulerOutA,
double *EulerOutB,
double *EulerOutC,
double *ResultFracOverlap,
double hkls[5000][4],
double Thetas[5000],
int n_hkls,
double *LsdFit,
double *TiltsFit,
double **BCsFit,
double tolLsd,
double tolLsdRel,
double tolTilts,
double tolBCsa,
double tolBCsb)
{
unsigned n;
long int i,j;
n = 6+(nLayers*3);
double x[n],xl[n],xu[n];
for (i=0;i<n;i++){
x[i] = 0;
xl[i] = 0;
xu[i] = 0;
}
for( i=0; i<3; i++)
{
x[i] = EulerIn[i];
xl[i] = x[i] - (tol*M_PI/180);
xu[i] = x[i] + (tol*M_PI/180);
}
int count = 0;
for (i=3;i<6;i++)
{
x[i] = TiltsOrig[count];
xl[i] = x[i] - tolTilts;
xu[i] = x[i] + tolTilts;
count++;
}
count = 0;
x[6] = Lsd[0];
xl[6] = x[6] - tolLsd;
xu[6] = x[6] + tolLsd;
count++;
for (i=7;i<nLayers+6;i++)
{
x[i] = Lsd[count] - Lsd[count-1];
xl[i] = x[i] - tolLsdRel;
xu[i] = x[i] + tolLsdRel;
count++;
}
count = 0;
for (i=6+nLayers;i<6+(nLayers*2);i++)
{
x[i] = ybc[count];
x[i+nLayers] = zbc[count];
xl[i] = x[i] - tolBCsa;
xl[i+nLayers] = x[i+nLayers] - tolBCsb;
xu[i] = x[i] + tolBCsa;
xu[i+nLayers] = x[i+nLayers] + tolBCsb;
count++;
}
struct my_func_data f_data;
f_data.NrOfFiles = NrOfFiles;
f_data.nLayers = nLayers;
f_data.n_hkls = n_hkls;
for (i=0;i<5000;i++){
f_data.hkls[i][0] = hkls[i][0];
f_data.hkls[i][1] = hkls[i][1];
f_data.hkls[i][2] = hkls[i][2];
f_data.hkls[i][3] = hkls[i][3];
f_data.Thetas[i] = Thetas[i];
}
f_data.ExcludePoleAngle = ExcludePoleAngle;
f_data.SizeObsSpots = SizeObsSpots;
f_data.P0 = allocMatrixF(nLayers,3);
for (i=0;i<3;i++){
f_data.XGrain[i] = XGrain[i];
f_data.YGrain[i] = YGrain[i];
for (j=0;j<nLayers;j++){
f_data.P0[j][i] = P0[j][i];
}
}
for (i=0;i<MAX_N_OMEGA_RANGES;i++){
for (j=0;j<2;j++){
f_data.OmegaRanges[i][j] = OmegaRanges[i][j];
}
for (j=0;j<4;j++){
f_data.BoxSizes[i][j] = BoxSizes[i][j];
}
}
f_data.ObsSpotsInfo = &ObsSpotsInfo[0];
f_data.OmegaStart = OmegaStart;
f_data.OmegaStep = OmegaStep;
f_data.px = px;
f_data.gs = gs;
f_data.NoOfOmegaRanges = NoOfOmegaRanges;
f_data.NrPixelsGrid = NrPixelsGrid;
struct my_func_data *f_datat;
f_datat = &f_data;
void* trp = (struct my_func_data *) f_datat;
double tole = 1e-3;
nlopt_opt opt;
opt = nlopt_create(NLOPT_LN_NELDERMEAD, n);
nlopt_set_lower_bounds(opt, xl);
nlopt_set_upper_bounds(opt, xu);
nlopt_set_min_objective(opt, problem_function, trp);
double minf=1;
nlopt_optimize(opt, x, &minf);
nlopt_destroy(opt);
*ResultFracOverlap = minf;
*EulerOutA = x[0];
*EulerOutB = x[1];
*EulerOutC = x[2];
TiltsFit[0] = x[3];
TiltsFit[1] = x[4];
TiltsFit[2] = x[5];
LsdFit[0] = x[6];
for (i=1;i<nLayers;i++){
LsdFit[i] = LsdFit[i-1] + x[6+i];
}
for (i=0;i<nLayers;i++){
BCsFit[i][0] = x[6+nLayers+i];
BCsFit[i][1] = x[6+nLayers+nLayers+i];
}
}
int main(int argc, char **argv)
{
/* -------Initialize and Get the parameters from command line ------*/
PetscInitialize(&argc, &argv, PETSC_NULL, PETSC_NULL);
PetscPrintf(PETSC_COMM_WORLD,"--------Initializing------ \n");
PetscErrorCode ierr;
PetscBool flg;
int myrank;
MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
if(myrank==0)
mma_verbose=1;
/*-------------------------------------------------*/
int Mx,My,Mz,Mzslab, Npmlx,Npmly,Npmlz,DegFree, anisotropic;
PetscOptionsGetInt(PETSC_NULL,"-Nx",&Nx,&flg); MyCheckAndOutputInt(flg,Nx,"Nx","Nx");
PetscOptionsGetInt(PETSC_NULL,"-Ny",&Ny,&flg); MyCheckAndOutputInt(flg,Ny,"Ny","Nx");
PetscOptionsGetInt(PETSC_NULL,"-Nz",&Nz,&flg); MyCheckAndOutputInt(flg,Nz,"Nz","Nz");
PetscOptionsGetInt(PETSC_NULL,"-Mx",&Mx,&flg); MyCheckAndOutputInt(flg,Mx,"Mx","Mx");
PetscOptionsGetInt(PETSC_NULL,"-My",&My,&flg); MyCheckAndOutputInt(flg,My,"My","My");
PetscOptionsGetInt(PETSC_NULL,"-Mz",&Mz,&flg); MyCheckAndOutputInt(flg,Mz,"Mz","Mz");
PetscOptionsGetInt(PETSC_NULL,"-Mzslab",&Mzslab,&flg); MyCheckAndOutputInt(flg,Mzslab,"Mzslab","Mzslab");
PetscOptionsGetInt(PETSC_NULL,"-Npmlx",&Npmlx,&flg); MyCheckAndOutputInt(flg,Npmlx,"Npmlx","Npmlx");
PetscOptionsGetInt(PETSC_NULL,"-Npmly",&Npmly,&flg); MyCheckAndOutputInt(flg,Npmly,"Npmly","Npmly");
PetscOptionsGetInt(PETSC_NULL,"-Npmlz",&Npmlz,&flg); MyCheckAndOutputInt(flg,Npmlz,"Npmlz","Npmlz");
Nxyz = Nx*Ny*Nz;
// if anisotropic !=0, Degree of Freedom = 3*Mx*My*Mz; else DegFree = Mx*My*Mz;
PetscOptionsGetInt(PETSC_NULL,"-anisotropic",&anisotropic,&flg);
if(!flg) anisotropic = 0; // by default, it is isotropc.
DegFree = (anisotropic ? 3 : 1 )*Mx*My*((Mzslab==0)?Mz:1);
PetscPrintf(PETSC_COMM_WORLD," the Degree of Freedoms is %d \n ", DegFree);
int DegFreeAll=DegFree+1;
PetscPrintf(PETSC_COMM_WORLD," the Degree of Freedoms ALL is %d \n ", DegFreeAll);
int BCPeriod, Jdirection, Jdirectiontwo, LowerPML;
int bx[2], by[2], bz[2];
PetscOptionsGetInt(PETSC_NULL,"-BCPeriod",&BCPeriod,&flg); MyCheckAndOutputInt(flg,BCPeriod,"BCPeriod","BCPeriod given");
PetscOptionsGetInt(PETSC_NULL,"-Jdirection",&Jdirection,&flg); MyCheckAndOutputInt(flg,Jdirection,"Jdirection","Diapole current direction");
PetscOptionsGetInt(PETSC_NULL,"-Jdirectiontwo",&Jdirectiontwo,&flg); MyCheckAndOutputInt(flg,Jdirectiontwo,"Jdirectiontwo","Diapole current direction for source two");
PetscOptionsGetInt(PETSC_NULL,"-LowerPML",&LowerPML,&flg); MyCheckAndOutputInt(flg,LowerPML,"LowerPML","PML in the lower xyz boundary");
PetscOptionsGetInt(PETSC_NULL,"-bxl",bx,&flg); MyCheckAndOutputInt(flg,bx[0],"bxl","BC at x lower");
PetscOptionsGetInt(PETSC_NULL,"-bxu",bx+1,&flg); MyCheckAndOutputInt(flg,bx[1],"bxu","BC at x upper");
PetscOptionsGetInt(PETSC_NULL,"-byl",by,&flg); MyCheckAndOutputInt(flg,by[0],"byl","BC at y lower");
PetscOptionsGetInt(PETSC_NULL,"-byu",by+1,&flg); MyCheckAndOutputInt(flg,by[1],"byu","BC at y upper");
PetscOptionsGetInt(PETSC_NULL,"-bzl",bz,&flg); MyCheckAndOutputInt(flg,bz[0],"bzl","BC at z lower");
PetscOptionsGetInt(PETSC_NULL,"-bzu",bz+1,&flg); MyCheckAndOutputInt(flg,bz[1],"bzu","BC at z upper");
double epssub, RRT, sigmax, sigmay, sigmaz ;
PetscOptionsGetReal(PETSC_NULL,"-hx",&hx,&flg); MyCheckAndOutputDouble(flg,hx,"hx","hx");
hy = hx;
hz = hx;
hxyz = (Nz==1)*hx*hy + (Nz>1)*hx*hy*hz;
double omega, omegaone, omegatwo, wratio;
PetscOptionsGetReal(PETSC_NULL,"-omega",&omega,&flg); MyCheckAndOutputDouble(flg,omega,"omega","omega");
PetscOptionsGetReal(PETSC_NULL,"-wratio",&wratio,&flg); MyCheckAndOutputDouble(flg,wratio,"wratio","wratio");
omegaone=omega;
omegatwo=wratio*omega;
PetscPrintf(PETSC_COMM_WORLD,"---omegaone is %.16e and omegatwo is %.16e ---\n",omegaone, omegatwo);
PetscOptionsGetReal(PETSC_NULL,"-Qabs",&Qabs,&flg);
if (flg && Qabs>1e+15)
Qabs=1.0/0.0;
MyCheckAndOutputDouble(flg,Qabs,"Qabs","Qabs");
PetscOptionsGetReal(PETSC_NULL,"-epsair",&epsair,&flg); MyCheckAndOutputDouble(flg,epsair,"epsair","epsair");
PetscOptionsGetReal(PETSC_NULL,"-epssub",&epssub,&flg); MyCheckAndOutputDouble(flg,epssub,"epssub","epssub");
PetscOptionsGetReal(PETSC_NULL,"-RRT",&RRT,&flg); MyCheckAndOutputDouble(flg,RRT,"RRT","RRT given");
sigmax = pmlsigma(RRT,Npmlx*hx);
sigmay = pmlsigma(RRT,Npmly*hy);
sigmaz = pmlsigma(RRT,Npmlz*hz);
PetscPrintf(PETSC_COMM_WORLD,"----sigmax is %.12e \n",sigmax);
PetscPrintf(PETSC_COMM_WORLD,"----sigmay is %.12e \n",sigmay);
PetscPrintf(PETSC_COMM_WORLD,"----sigmaz is %.12e \n",sigmaz);
char initialdata[PETSC_MAX_PATH_LEN]; //filenameComm[PETSC_MAX_PATH_LEN];
PetscOptionsGetString(PETSC_NULL,"-initialdata",initialdata,PETSC_MAX_PATH_LEN,&flg); MyCheckAndOutputChar(flg,initialdata,"initialdata","Inputdata file");
PetscOptionsGetString(PETSC_NULL,"-filenameComm",filenameComm,PETSC_MAX_PATH_LEN,&flg); MyCheckAndOutputChar(flg,filenameComm,"filenameComm","Output filenameComm");
// add cx, cy, cz to indicate where the diapole current is;
int cx, cy, cz;
PetscOptionsGetInt(PETSC_NULL,"-cx",&cx,&flg);
if (!flg)
{cx=(LowerPML)*floor(Nx/2); PetscPrintf(PETSC_COMM_WORLD,"cx is %d by default \n",cx);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cx is %d \n",cx);}
PetscOptionsGetInt(PETSC_NULL,"-cy",&cy,&flg);
if (!flg)
{cy=(LowerPML)*floor(Ny/2); PetscPrintf(PETSC_COMM_WORLD,"cy is %d by default \n",cy);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cy is %d \n",cy);}
PetscOptionsGetInt(PETSC_NULL,"-cz",&cz,&flg);
if (!flg)
{cz=(LowerPML)*floor(Nz/2); PetscPrintf(PETSC_COMM_WORLD,"cz is %d by default \n",cz);}
else
{PetscPrintf(PETSC_COMM_WORLD,"the current poisiont cz is %d \n",cz);}
posj = (cx*Ny+ cy)*Nz + cz;
PetscPrintf(PETSC_COMM_WORLD,"the posj is %d \n. ", posj);
int fixpteps;
PetscOptionsGetInt(PETSC_NULL,"-fixpteps",&fixpteps,&flg); MyCheckAndOutputInt(flg,fixpteps,"fixpteps","fixpteps");
// Get minapproach;
PetscOptionsGetInt(PETSC_NULL,"-minapproach",&minapproach,&flg); MyCheckAndOutputInt(flg,minapproach,"minapproach","minapproach");
// Get withepsinldos;
PetscOptionsGetInt(PETSC_NULL,"-withepsinldos",&withepsinldos,&flg); MyCheckAndOutputInt(flg,withepsinldos,"withepsinldos","withepsinldos");
// Get outputbase;
PetscOptionsGetInt(PETSC_NULL,"-outputbase",&outputbase,&flg); MyCheckAndOutputInt(flg,outputbase,"outputbase","outputbase");
// Get cavityverbose;
PetscOptionsGetInt(PETSC_NULL,"-cavityverbose",&cavityverbose,&flg);
if(!flg) cavityverbose=0;
PetscPrintf(PETSC_COMM_WORLD,"the cavity verbose is set as %d \n", cavityverbose);
// Get refinedldos;
PetscOptionsGetInt(PETSC_NULL,"-refinedldos",&refinedldos,&flg);
if(!flg) refinedldos=0;
PetscPrintf(PETSC_COMM_WORLD,"the refinedldos is set as %d \n", refinedldos);
// Get cmpwrhs;
int cmpwrhs;
PetscOptionsGetInt(PETSC_NULL,"-cmpwrhs",&cmpwrhs,&flg);
if(!flg) cmpwrhs=0;
PetscPrintf(PETSC_COMM_WORLD,"the cmpwrhs is set as %d \n", cmpwrhs);
// Get lrzsqr;
PetscOptionsGetInt(PETSC_NULL,"-lrzsqr",&lrzsqr,&flg);
if(!flg) lrzsqr=0;
PetscPrintf(PETSC_COMM_WORLD,"the lrzsqr is set as %d \n", lrzsqr);
// Get newQdef;
PetscOptionsGetInt(PETSC_NULL,"-newQdef",&newQdef,&flg);
if(!flg) newQdef=0;
PetscPrintf(PETSC_COMM_WORLD,"the newQdef is set as %d \n", newQdef);
/*--------------------------------------------------------*/
/*--------------------------------------------------------*/
/*---------- Set the current source---------*/
//Mat D; //ImaginaryIMatrix;
ImagIMat(PETSC_COMM_WORLD, &D,6*Nxyz);
Vec J;
ierr = VecCreateMPI(PETSC_COMM_WORLD, PETSC_DECIDE, 6*Nxyz, &J);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) J, "Source");CHKERRQ(ierr);
VecSet(J,0.0); //initialization;
if (Jdirection == 1)
SourceSingleSetX(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirection ==2)
SourceSingleSetY(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirection == 3)
SourceSingleSetZ(PETSC_COMM_WORLD, J, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else
PetscPrintf(PETSC_COMM_WORLD," Please specify correct direction of current: x (1) , y (2) or z (3)\n ");
Vec Jtwo;
ierr = VecDuplicate(J, &Jtwo);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) Jtwo, "Sourcetwo");CHKERRQ(ierr);
VecSet(Jtwo,0.0); //initialization;
if (Jdirectiontwo == 1)
SourceSingleSetX(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirectiontwo ==2)
SourceSingleSetY(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else if (Jdirectiontwo == 3)
SourceSingleSetZ(PETSC_COMM_WORLD, Jtwo, Nx, Ny, Nz, cx, cy, cz,1.0/hxyz);
else
PetscPrintf(PETSC_COMM_WORLD," Please specify correct direction of current two: x (1) , y (2) or z (3)\n ");
//Vec b; // b= i*omega*J;
Vec bone, btwo;
ierr = VecDuplicate(J,&b);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) b, "rhsone");CHKERRQ(ierr);
ierr = VecDuplicate(J,&bone);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) bone, "rhsone");CHKERRQ(ierr);
ierr = VecDuplicate(Jtwo,&btwo);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) btwo, "rhstwo");CHKERRQ(ierr);
if (cmpwrhs==0)
{
ierr = MatMult(D,J,b);CHKERRQ(ierr);
ierr = MatMult(D,Jtwo,btwo);CHKERRQ(ierr);
VecCopy(b,bone);
VecScale(bone,omegaone);
VecScale(btwo,omegatwo);
VecScale(b,omega);
}
else
{
double complex cmpiomega;
cmpiomega = cpow(1+I/Qabs,newQdef+1);
double sqrtiomegaR = -omega*cimag(csqrt(cmpiomega));
double sqrtiomegaI = omega*creal(csqrt(cmpiomega));
PetscPrintf(PETSC_COMM_WORLD,"the real part of sqrt cmpomega is %g and imag sqrt is % g ", sqrtiomegaR, sqrtiomegaI);
Vec tmpi;
ierr = VecDuplicate(J,&tmpi);
VecSet(b,0.0);
VecSet(tmpi,0.0);
CmpVecScale(J,b,sqrtiomegaR,sqrtiomegaI,D,tmpi);
VecDestroy(&tmpi);
}
/*-------Get the weight vector ------------------*/
//Vec weight;
ierr = VecDuplicate(J,&weight); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) weight, "weight");CHKERRQ(ierr);
if(LowerPML==0)
GetWeightVec(weight, Nx, Ny,Nz); // new code handles both 3D and 2D;
else
VecSet(weight,1.0);
Vec weightedJ;
ierr = VecDuplicate(J,&weightedJ); CHKERRQ(ierr);
ierr = VecPointwiseMult(weightedJ,J,weight);
ierr = PetscObjectSetName((PetscObject) weightedJ, "weightedJ");CHKERRQ(ierr);
Vec weightedJtwo;
ierr = VecDuplicate(Jtwo,&weightedJtwo); CHKERRQ(ierr);
ierr = VecPointwiseMult(weightedJtwo,Jtwo,weight);
ierr = PetscObjectSetName((PetscObject) weightedJtwo, "weightedJtwo");CHKERRQ(ierr);
//Vec vR;
ierr = VecDuplicate(J,&vR); CHKERRQ(ierr);
GetRealPartVec(vR, 6*Nxyz);
// VecFReal;
if (lrzsqr)
{ ierr = VecDuplicate(J,&epsFReal); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsFReal, "epsFReal");CHKERRQ(ierr);
if (newQdef==0)
{
sqrtomegaI = omega*cimag(csqrt(1+I/Qabs));
PetscPrintf(PETSC_COMM_WORLD,"the real part of sqrt cmpomega is %g and imag sqrt is % g ", omega*creal(csqrt(1+I/Qabs)), sqrtomegaI);
betar = 2*sqrtomegaI;
betai = betar/Qabs;
}
else
{
double gamma;
gamma = omega/Qabs;
betar = 2*gamma*(1-1.0/pow(Qabs,2));
betai = 2*gamma*(2.0/Qabs);
}
ierr = VecDuplicate(J,&nb); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) nb, "nb"); CHKERRQ(ierr);
ierr = VecDuplicate(J,&y); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) y, "y"); CHKERRQ(ierr);
ierr = VecDuplicate(J,&xsqr); CHKERRQ(ierr); // xsqr = x*x;
ierr = PetscObjectSetName((PetscObject) xsqr, "xsqr"); CHKERRQ(ierr);
CongMat(PETSC_COMM_WORLD, &C, 6*Nxyz);
}
/*----------- Define PML muinv vectors */
Vec muinvpml;
MuinvPMLFull(PETSC_COMM_SELF, &muinvpml,Nx,Ny,Nz,Npmlx,Npmly,Npmlz,sigmax,sigmay,sigmaz,omega, LowerPML);
//double *muinv;
muinv = (double *) malloc(sizeof(double)*6*Nxyz);
int add=0;
AddMuAbsorption(muinv,muinvpml,Qabs,add);
ierr = VecDestroy(&muinvpml); CHKERRQ(ierr);
/*---------- Define PML eps vectors: epspml---------- */
Vec epspml; //epspmlQ, epscoef;
ierr = VecDuplicate(J,&epspml);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epspml,"EpsPMLFull"); CHKERRQ(ierr);
EpsPMLFull(PETSC_COMM_WORLD, epspml,Nx,Ny,Nz,Npmlx,Npmly,Npmlz,sigmax,sigmay,sigmaz,omega, LowerPML);
ierr = VecDuplicate(J,&epspmlQ);CHKERRQ(ierr);
Vec epscoefone, epscoeftwo;
ierr = VecDuplicate(J,&epscoefone);CHKERRQ(ierr);
ierr = VecDuplicate(J,&epscoeftwo);CHKERRQ(ierr);
// compute epspmlQ,epscoef;
EpsCombine(D, weight, epspml, epspmlQ, epscoefone, Qabs, omegaone);
EpsCombine(D, weight, epspml, epspmlQ, epscoeftwo, Qabs, omegatwo);
/*--------- Setup the interp matrix ----------------------- */
/* for a samll eps block, interp it into yee-lattice. The interp matrix A and PML epspml only need to generated once;*/
//Mat A;
//new routine for myinterp;
myinterp(PETSC_COMM_WORLD, &A, Nx,Ny,Nz, LowerPML*floor((Nx-Mx)/2),LowerPML*floor((Ny-My)/2),LowerPML*floor((Nz-Mz)/2), Mx,My,Mz,Mzslab, anisotropic); // LoweerPML*Npmlx,..,.., specify where the interp starts;
//Vec epsSReal, epsgrad, vgrad; // create compatiable vectors with A.
ierr = MatGetVecs(A,&epsSReal, &epsgrad); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsgrad, "epsgrad");CHKERRQ(ierr);
ierr = VecDuplicate(epsSReal, &vgrad); CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsSReal, "epsSReal");CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) vgrad, "vgrad");CHKERRQ(ierr);
/*---------Setup the epsmedium vector----------------*/
//Vec epsmedium;
ierr = VecDuplicate(J,&epsmedium); CHKERRQ(ierr);
GetMediumVec(epsmedium,Nz,Mz,epsair,epssub);
/*--------- Setup the finitie difference matrix-------------*/
//Mat M;
MoperatorGeneral(PETSC_COMM_WORLD, &M, Nx,Ny,Nz,hx,hy,hz, bx, by, bz,muinv,BCPeriod);
free(muinv);
/*--------Setup the KSP variables ---------------*/
KSP kspone;
PC pcone;
ierr = KSPCreate(PETSC_COMM_WORLD,&kspone);CHKERRQ(ierr);
//ierr = KSPSetType(ksp, KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetType(kspone, KSPGMRES);CHKERRQ(ierr);
ierr = KSPGetPC(kspone,&pcone);CHKERRQ(ierr);
ierr = PCSetType(pcone,PCLU);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pcone,MATSOLVERPASTIX);CHKERRQ(ierr);
ierr = PCSetFromOptions(pcone);
int maxkspit = 20;
ierr = KSPSetTolerances(kspone,1e-14,PETSC_DEFAULT,PETSC_DEFAULT,maxkspit);CHKERRQ(ierr);
ierr = KSPSetFromOptions(kspone);CHKERRQ(ierr);
KSP ksptwo;
PC pctwo;
ierr = KSPCreate(PETSC_COMM_WORLD,&ksptwo);CHKERRQ(ierr);
//ierr = KSPSetType(ksp, KSPPREONLY);CHKERRQ(ierr);
ierr = KSPSetType(ksptwo, KSPGMRES);CHKERRQ(ierr);
ierr = KSPGetPC(ksptwo,&pctwo);CHKERRQ(ierr);
ierr = PCSetType(pctwo,PCLU);CHKERRQ(ierr);
ierr = PCFactorSetMatSolverPackage(pctwo,MATSOLVERPASTIX);CHKERRQ(ierr);
ierr = PCSetFromOptions(pctwo);
ierr = KSPSetTolerances(ksptwo,1e-14,PETSC_DEFAULT,PETSC_DEFAULT,maxkspit);CHKERRQ(ierr);
ierr = KSPSetFromOptions(ksptwo);CHKERRQ(ierr);
/*--------- Create the space for solution vector -------------*/
//Vec x;
ierr = VecDuplicate(J,&x);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) x, "Solution");CHKERRQ(ierr);
/*----------- Create the space for final eps -------------*/
//Vec epsC, epsCi, epsP;
ierr = VecDuplicate(J,&epsC);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) epsC, "EpsC");CHKERRQ(ierr);
ierr = VecDuplicate(J,&epsCi);CHKERRQ(ierr);
ierr = VecDuplicate(J,&epsP);CHKERRQ(ierr);
ierr = VecSet(epsP,0.0); CHKERRQ(ierr);
ierr = VecAssemblyBegin(epsP); CHKERRQ(ierr);
ierr = VecAssemblyEnd(epsP); CHKERRQ(ierr);
/*------------ Create space used in the solver ------------*/
//Vec vgradlocal,tmp, tmpa,tmpb;
ierr = VecCreateSeq(PETSC_COMM_SELF, DegFree, &vgradlocal); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmp); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmpa); CHKERRQ(ierr);
ierr = VecDuplicate(J,&tmpb); CHKERRQ(ierr);
// Vec pickposvec; this vector is zero except that first entry is one;
if (withepsinldos)
{ ierr = VecDuplicate(J,&pickposvec); CHKERRQ(ierr);
ierr = VecSet(pickposvec,0.0); CHKERRQ(ierr);
ierr = VecSetValue(pickposvec,posj+Jdirection*Nxyz,1.0,INSERT_VALUES);
VecAssemblyBegin(pickposvec);
VecAssemblyEnd(pickposvec);
}
/*------------ Create scatter used in the solver -----------*/
//VecScatter scatter;
//IS from, to;
ierr =ISCreateStride(PETSC_COMM_SELF,DegFree,0,1,&from); CHKERRQ(ierr);
ierr =ISCreateStride(PETSC_COMM_SELF,DegFree,0,1,&to); CHKERRQ(ierr);
/*-------------Read the input file -------------------------*/
double *epsoptAll;
epsoptAll = (double *) malloc(DegFreeAll*sizeof(double));
FILE *ptf;
ptf = fopen(initialdata,"r");
PetscPrintf(PETSC_COMM_WORLD,"reading from input files \n");
int i;
// set the dielectric at the center is fixed, and alwyas high
//epsopt[0]=myub; is defined below near lb and ub;
for (i=0;i<DegFree;i++)
{ //PetscPrintf(PETSC_COMM_WORLD,"current eps reading is %lf \n",epsopt[i]);
fscanf(ptf,"%lf",&epsoptAll[i]);
}
epsoptAll[DegFreeAll-1]=0; //initialize auxiliary variable;
fclose(ptf);
/*----declare these data types, althought they may not be used for job 2 -----------------*/
double mylb,myub, *lb=NULL, *ub=NULL;
int maxeval, maxtime, mynloptalg;
double maxf;
nlopt_opt opt;
nlopt_result result;
/*--------------------------------------------------------------*/
/*----Now based on Command Line, Do the corresponding job----*/
/*----------------------------------------------------------------*/
//int Job; set Job to be gloabl variables;
PetscOptionsGetInt(PETSC_NULL,"-Job",&Job,&flg); MyCheckAndOutputInt(flg,Job,"Job","The Job indicator you set");
int numofvar=(Job==1)*DegFreeAll + (Job==3);
/*-------- convert the epsopt array to epsSReal (if job!=optmization) --------*/
if (Job==2 || Job ==3)
{
// copy epsilon from file to epsSReal; (different from FindOpt.c, because epsilon is not degree-of-freedoms in computeQ.
// i) create a array to read file (done above in epsopt); ii) convert the array to epsSReal;
int ns, ne;
ierr = VecGetOwnershipRange(epsSReal,&ns,&ne);
for(i=ns;i<ne;i++)
{ ierr=VecSetValue(epsSReal,i,epsoptAll[i],INSERT_VALUES);
CHKERRQ(ierr); }
if(withepsinldos)
{ epsatinterest = epsoptAll[cx*Ny*Nz + cy*Nz + cz] + epsair;
PetscPrintf(PETSC_COMM_WORLD, " the relative permitivity at the point of current is %.16e \n ",epsatinterest);}
ierr = VecAssemblyBegin(epsSReal); CHKERRQ(ierr);
ierr = VecAssemblyEnd(epsSReal); CHKERRQ(ierr);
}
if (Job==1 || Job==3) // optimization bounds setup;
{
PetscOptionsGetInt(PETSC_NULL,"-maxeval",&maxeval,&flg); MyCheckAndOutputInt(flg,maxeval,"maxeval","max number of evaluation");
PetscOptionsGetInt(PETSC_NULL,"-maxtime",&maxtime,&flg); MyCheckAndOutputInt(flg,maxtime,"maxtime","max time of evaluation");
PetscOptionsGetInt(PETSC_NULL,"-mynloptalg",&mynloptalg,&flg); MyCheckAndOutputInt(flg,mynloptalg,"mynloptalg","The algorithm used ");
PetscOptionsGetReal(PETSC_NULL,"-mylb",&mylb,&flg); MyCheckAndOutputDouble(flg,mylb,"mylb","optimization lb");
PetscOptionsGetReal(PETSC_NULL,"-myub",&myub,&flg); MyCheckAndOutputDouble(flg,myub,"myub","optimization ub");
lb = (double *) malloc(numofvar*sizeof(double));
ub = (double *) malloc(numofvar*sizeof(double));
// the dielectric constant at center is fixed!
for(i=0;i<numofvar;i++)
{
lb[i] = mylb;
ub[i] = myub;
} //initial guess, lower bounds, upper bounds;
// set lower and upper bounds for auxiliary variable;
lb[numofvar-1]=0;
ub[numofvar-1]=1.0/0.0;
//fix the dielectric at the center to be high for topology optimization;
if (Job==1 && fixpteps==1)
{
epsoptAll[0]=myub;
lb[0]=myub;
ub[0]=myub;
}
opt = nlopt_create(mynloptalg, numofvar);
myfundatatypeshg data[2] = {{omegaone, bone, weightedJ, epscoefone,kspone},{omegatwo, btwo, weightedJtwo, epscoeftwo,ksptwo}};
nlopt_add_inequality_constraint(opt,ldosconstraint, &data[0], 1e-8);
nlopt_add_inequality_constraint(opt,ldosconstraint, &data[1], 1e-8);
nlopt_set_lower_bounds(opt,lb);
nlopt_set_upper_bounds(opt,ub);
nlopt_set_maxeval(opt,maxeval);
nlopt_set_maxtime(opt,maxtime);
/*add functionality to choose local optimizer; */
int mynloptlocalalg;
nlopt_opt local_opt;
PetscOptionsGetInt(PETSC_NULL,"-mynloptlocalalg",&mynloptlocalalg,&flg); MyCheckAndOutputInt(flg,mynloptlocalalg,"mynloptlocalalg","The local optimization algorithm used ");
if (mynloptlocalalg)
{
local_opt=nlopt_create(mynloptlocalalg,numofvar);
nlopt_set_ftol_rel(local_opt, 1e-14);
nlopt_set_maxeval(local_opt,100000);
nlopt_set_local_optimizer(opt,local_opt);
}
}
switch (Job)
{
case 1:
{
if (minapproach)
nlopt_set_min_objective(opt,maxminobjfun,NULL);// NULL: no data to be passed because of global variables;
else
nlopt_set_max_objective(opt,maxminobjfun,NULL);
result = nlopt_optimize(opt,epsoptAll,&maxf);
}
break;
case 2 : //AnalyzeStructure
{
int Linear, Eig, maxeigit;
PetscOptionsGetInt(PETSC_NULL,"-Linear",&Linear,&flg); MyCheckAndOutputInt(flg,Linear,"Linear","Linear solver indicator");
PetscOptionsGetInt(PETSC_NULL,"-Eig",&Eig,&flg); MyCheckAndOutputInt(flg,Eig,"Eig","Eig solver indicator");
PetscOptionsGetInt(PETSC_NULL,"-maxeigit",&maxeigit,&flg); MyCheckAndOutputInt(flg,maxeigit,"maxeigit","maximum number of Eig solver iterations is");
/*----------------------------------*/
//EigenSolver(Linear, Eig, maxeigit);
/*----------------------------------*/
OutputVec(PETSC_COMM_WORLD, weight,filenameComm, "weight.m");
}
break;
default:
PetscPrintf(PETSC_COMM_WORLD,"--------Interesting! You're doing nothing!--------\n ");
}
if(Job==1 || Job==3)
{
/* print the optimization parameters */
#if 0
double xrel, frel, fabs;
// double *xabs;
frel=nlopt_get_ftol_rel(opt);
fabs=nlopt_get_ftol_abs(opt);
xrel=nlopt_get_xtol_rel(opt);
PetscPrintf(PETSC_COMM_WORLD,"nlopt frel is %g \n",frel);
PetscPrintf(PETSC_COMM_WORLD,"nlopt fabs is %g \n",fabs);
PetscPrintf(PETSC_COMM_WORLD,"nlopt xrel is %g \n",xrel);
//nlopt_result nlopt_get_xtol_abs(const nlopt_opt opt, double *tol);
#endif
/*--------------*/
if (result < 0) {
PetscPrintf(PETSC_COMM_WORLD,"nlopt failed! \n", result);
}
else {
PetscPrintf(PETSC_COMM_WORLD,"found extremum %0.16e\n", minapproach?1.0/maxf:maxf);
}
PetscPrintf(PETSC_COMM_WORLD,"nlopt returned value is %d \n", result);
if(Job==1)
{ //OutputVec(PETSC_COMM_WORLD, epsopt,filenameComm, "epsopt.m");
//OutputVec(PETSC_COMM_WORLD, epsgrad,filenameComm, "epsgrad.m");
//OutputVec(PETSC_COMM_WORLD, vgrad,filenameComm, "vgrad.m");
//OutputVec(PETSC_COMM_WORLD, x,filenameComm, "x.m");
int rankA;
MPI_Comm_rank(PETSC_COMM_WORLD, &rankA);
if(rankA==0)
{
ptf = fopen(strcat(filenameComm,"epsopt.txt"),"w");
for (i=0;i<DegFree;i++)
fprintf(ptf,"%0.16e \n",epsoptAll[i]);
fclose(ptf);
PetscPrintf(PETSC_COMM_WORLD,"the t parameter is %.8e \n",epsoptAll[DegFreeAll-1]);
}
}
nlopt_destroy(opt);
}
ierr = PetscPrintf(PETSC_COMM_WORLD,"--------Done!--------\n ");CHKERRQ(ierr);
/*------------------------------------*/
/* ----------------------Destroy Vecs and Mats----------------------------*/
free(epsoptAll);
free(lb);
free(ub);
ierr = VecDestroy(&J); CHKERRQ(ierr);
ierr = VecDestroy(&b); CHKERRQ(ierr);
ierr = VecDestroy(&weight); CHKERRQ(ierr);
ierr = VecDestroy(&weightedJ); CHKERRQ(ierr);
ierr = VecDestroy(&vR); CHKERRQ(ierr);
ierr = VecDestroy(&epspml); CHKERRQ(ierr);
ierr = VecDestroy(&epspmlQ); CHKERRQ(ierr);
ierr = VecDestroy(&epsSReal); CHKERRQ(ierr);
ierr = VecDestroy(&epsgrad); CHKERRQ(ierr);
ierr = VecDestroy(&vgrad); CHKERRQ(ierr);
ierr = VecDestroy(&epsmedium); CHKERRQ(ierr);
ierr = VecDestroy(&epsC); CHKERRQ(ierr);
ierr = VecDestroy(&epsCi); CHKERRQ(ierr);
ierr = VecDestroy(&epsP); CHKERRQ(ierr);
ierr = VecDestroy(&x); CHKERRQ(ierr);
ierr = VecDestroy(&vgradlocal);CHKERRQ(ierr);
ierr = VecDestroy(&tmp); CHKERRQ(ierr);
ierr = VecDestroy(&tmpa); CHKERRQ(ierr);
ierr = VecDestroy(&tmpb); CHKERRQ(ierr);
ierr = MatDestroy(&A); CHKERRQ(ierr);
ierr = MatDestroy(&D); CHKERRQ(ierr);
ierr = MatDestroy(&M); CHKERRQ(ierr);
ierr = VecDestroy(&epscoefone); CHKERRQ(ierr);
ierr = VecDestroy(&epscoeftwo); CHKERRQ(ierr);
ierr = KSPDestroy(&kspone);CHKERRQ(ierr);
ierr = KSPDestroy(&ksptwo);CHKERRQ(ierr);
ISDestroy(&from);
ISDestroy(&to);
if (withepsinldos)
{ierr=VecDestroy(&pickposvec); CHKERRQ(ierr);}
if (lrzsqr)
{
ierr=VecDestroy(&epsFReal); CHKERRQ(ierr);
ierr=VecDestroy(&xsqr); CHKERRQ(ierr);
ierr=VecDestroy(&y); CHKERRQ(ierr);
ierr=VecDestroy(&nb); CHKERRQ(ierr);
ierr=MatDestroy(&C); CHKERRQ(ierr);
}
ierr = VecDestroy(&bone); CHKERRQ(ierr);
ierr = VecDestroy(&btwo); CHKERRQ(ierr);
ierr = VecDestroy(&Jtwo); CHKERRQ(ierr);
/*------------ finalize the program -------------*/
{
int rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
//if (rank == 0) fgetc(stdin);
MPI_Barrier(PETSC_COMM_WORLD);
}
ierr = PetscFinalize(); CHKERRQ(ierr);
return 0;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
unsigned n;
double *x, *x0, opt_f;
nlopt_result ret;
mxArray *x_mx, *mx;
user_function_data d, dpre, *dfc = NULL, *dh = NULL;
nlopt_opt opt = NULL;
CHECK(nrhs == 2 && nlhs <= 3, "wrong number of arguments");
/* options = prhs[0] */
CHECK(mxIsStruct(prhs[0]), "opt must be a struct");
/* x0 = prhs[1] */
CHECK(mxIsDouble(prhs[1]) && !mxIsComplex(prhs[1])
&& (mxGetM(prhs[1]) == 1 || mxGetN(prhs[1]) == 1),
"x must be real row or column vector");
n = mxGetM(prhs[1]) * mxGetN(prhs[1]),
x0 = mxGetPr(prhs[1]);
CHECK(opt = make_opt(prhs[0], n), "error initializing nlopt options");
d.neval = 0;
d.verbose = (int) struct_val_default(prhs[0], "verbose", 0);
d.opt = opt;
/* function f = prhs[1] */
mx = struct_funcval(prhs[0], "min_objective");
if (!mx) mx = struct_funcval(prhs[0], "max_objective");
CHECK(mx, "either opt.min_objective or opt.max_objective must exist");
if (mxIsChar(mx)) {
CHECK(mxGetString(mx, d.f, FLEN) == 0,
"error reading function name string (too long?)");
d.nrhs = 1;
d.xrhs = 0;
}
else {
d.prhs[0] = mx;
strcpy(d.f, "feval");
d.nrhs = 2;
d.xrhs = 1;
}
d.prhs[d.xrhs] = mxCreateDoubleMatrix(1, n, mxREAL);
if ((mx = struct_funcval(prhs[0], "pre"))) {
CHECK(mxIsChar(mx) || mxIsFunctionHandle(mx),
"pre must contain function handles or function names");
if (mxIsChar(mx)) {
CHECK(mxGetString(mx, dpre.f, FLEN) == 0,
"error reading function name string (too long?)");
dpre.nrhs = 2;
dpre.xrhs = 0;
}
else {
dpre.prhs[0] = mx;
strcpy(dpre.f, "feval");
dpre.nrhs = 3;
dpre.xrhs = 1;
}
dpre.verbose = d.verbose > 2;
dpre.opt = opt;
dpre.neval = 0;
dpre.prhs[dpre.xrhs] = d.prhs[d.xrhs];
dpre.prhs[d.xrhs+1] = mxCreateDoubleMatrix(1, n, mxREAL);
d.dpre = &dpre;
if (struct_funcval(prhs[0], "min_objective"))
nlopt_set_precond_min_objective(opt, user_function,user_pre,&d);
else
nlopt_set_precond_max_objective(opt, user_function,user_pre,&d);
}
else {
dpre.nrhs = 0;
if (struct_funcval(prhs[0], "min_objective"))
nlopt_set_min_objective(opt, user_function, &d);
else
nlopt_set_max_objective(opt, user_function, &d);
}
if ((mx = mxGetField(prhs[0], 0, "fc"))) {
int j, m;
double *fc_tol;
CHECK(mxIsCell(mx), "fc must be a Cell array");
m = mxGetM(mx) * mxGetN(mx);;
dfc = (user_function_data *) mxCalloc(m, sizeof(user_function_data));
fc_tol = struct_arrval(prhs[0], "fc_tol", m, NULL);
for (j = 0; j < m; ++j) {
mxArray *fc = mxGetCell(mx, j);
CHECK(mxIsChar(fc) || mxIsFunctionHandle(fc),
"fc must contain function handles or function names");
if (mxIsChar(fc)) {
CHECK(mxGetString(fc, dfc[j].f, FLEN) == 0,
"error reading function name string (too long?)");
dfc[j].nrhs = 1;
dfc[j].xrhs = 0;
}
else {
dfc[j].prhs[0] = fc;
strcpy(dfc[j].f, "feval");
dfc[j].nrhs = 2;
dfc[j].xrhs = 1;
}
dfc[j].verbose = d.verbose > 1;
dfc[j].opt = opt;
dfc[j].neval = 0;
dfc[j].prhs[dfc[j].xrhs] = d.prhs[d.xrhs];
CHECK(nlopt_add_inequality_constraint(opt, user_function,
dfc + j,
fc_tol ? fc_tol[j] : 0)
> 0, "nlopt error adding inequality constraint");
}
}
if ((mx = mxGetField(prhs[0], 0, "h"))) {
int j, m;
double *h_tol;
CHECK(mxIsCell(mx), "h must be a Cell array");
m = mxGetM(mx) * mxGetN(mx);;
dh = (user_function_data *) mxCalloc(m, sizeof(user_function_data));
h_tol = struct_arrval(prhs[0], "h_tol", m, NULL);
for (j = 0; j < m; ++j) {
mxArray *h = mxGetCell(mx, j);
CHECK(mxIsChar(h) || mxIsFunctionHandle(h),
"h must contain function handles or function names");
if (mxIsChar(h)) {
CHECK(mxGetString(h, dh[j].f, FLEN) == 0,
"error reading function name string (too long?)");
dh[j].nrhs = 1;
dh[j].xrhs = 0;
}
else {
dh[j].prhs[0] = h;
strcpy(dh[j].f, "feval");
dh[j].nrhs = 2;
dh[j].xrhs = 1;
}
dh[j].verbose = d.verbose > 1;
dh[j].opt = opt;
dh[j].neval = 0;
dh[j].prhs[dh[j].xrhs] = d.prhs[d.xrhs];
CHECK(nlopt_add_equality_constraint(opt, user_function,
dh + j,
h_tol ? h_tol[j] : 0)
> 0, "nlopt error adding equality constraint");
}
}
x_mx = mxCreateDoubleMatrix(mxGetM(prhs[1]), mxGetN(prhs[1]), mxREAL);
x = mxGetPr(x_mx);
memcpy(x, x0, sizeof(double) * n);
ret = nlopt_optimize(opt, x, &opt_f);
mxFree(dh);
mxFree(dfc);
mxDestroyArray(d.prhs[d.xrhs]);
if (dpre.nrhs > 0) mxDestroyArray(dpre.prhs[d.xrhs+1]);
nlopt_destroy(opt);
plhs[0] = x_mx;
if (nlhs > 1) {
plhs[1] = mxCreateDoubleMatrix(1, 1, mxREAL);
*(mxGetPr(plhs[1])) = opt_f;
}
if (nlhs > 2) {
plhs[2] = mxCreateDoubleMatrix(1, 1, mxREAL);
*(mxGetPr(plhs[2])) = (int) ret;
}
}
NLfit::~NLfit()
{
if (opt_ != NULL)
nlopt_destroy(opt_);
}
double Optimize_Torsion_Parameters(void)
{
double lb[N_TOR_PARA] = {
-20.0, -PI,
-20.0, -PI,
-20.0, -PI,
-20.0, -PI,
-20.0, -PI,
-100 };
double ub[N_TOR_PARA] = {
+20.0, +PI,
+20.0, +PI,
+20.0, +PI,
+20.0, +PI,
+20.0, +PI,
+100 };
// double ub[N_TOR_PARA] = { 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 100.0 }; /* lower bounds */
nlopt_opt opt;
double Chi_SQ;
int i, j;
Chi_SQ_Min = 1.0E100;
for(i=0; i<NRUN; i++) { // was 32
ActiveRun = i;
Chi_SQ_Min_Local[i] = 1.0E200;
FailCount = Iteration = 0;
// for(j=0; j<5; j++) {
// Para_Tor[2*j] = 0.1+1.0*rand(iseed);
// }
for( i=0; i<11; i++ ) {
Para_Tor[i] = 0.;
IsPara_Fixed[i] = 0.;
} // inital values
//opt = nlopt_create(NLOPT_LD_LBFGS, N_TOR_PARA);
printf("=== Fitting ===\n" );
opt = nlopt_create(NLOPT_LN_COBYLA, N_TOR_PARA);
nlopt_set_lower_bounds(opt, lb);
nlopt_set_upper_bounds(opt, ub);
nlopt_set_min_objective(opt, Callback_Eval_Gradient, NULL);
nlopt_set_xtol_rel(opt, 1e-8);
if (nlopt_optimize(opt, Para_Tor, &Chi_SQ) < 0) {
printf("nlopt didn't converge %lf %lf\n Please check carefully the rotamer results\n",Chi_SQ_Min, Chi_SQ);
}
else {
printf("Chi_SQ_min = %lf Chi_SQ = %lf\n", Chi_SQ_Min, Chi_SQ);
}
nlopt_destroy(opt);
}
memcpy(Para_Tor, Para_Best, sizeof(double)*N_TOR_PARA);
CalObjectiveFunction_Tor(Para_Tor);
return Chi_SQ_Min;
}
Shredder::~Shredder()
{
nlopt_destroy(opt);
}
double Geoometry_Optimization_With_Constraint(CMol *pMol)
{
return (pMol->Cal_E(0));
nlopt_opt opt, opt_AugLag;
int Return_Opt, nAtom, nDim, i, iPos;
double E_min, x[MAX_NUM_ATOM*3];
Mol_ESP.Restrain_All_Torsions(1); // apply soft restraints on all soft dihedrals
nAtom = pMol->nAtom;
nDim = 3 * nAtom;
printf("\nMM before:\t");
for(i=0; i<n_Phi; i++) {
printf("%3d %3d %3d %3d %8.4lf\n", DihList[i][0], DihList[i][1], DihList[i][2], DihList[i][3],
Mol_ESP.Query_Dihedral(DihList[i][0], DihList[i][1], DihList[i][2], DihList[i][3], 0, NULL));
}
double AUG_LAG_ICM_TOL = 1.0E-17;
opt_AugLag = nlopt_create(NLOPT_LD_LBFGS_GEO, nDim);
nlopt_set_min_objective(opt_AugLag, func_Geo_Opt_Constraint, pMol);
// pMol->SavePdb("opt-free.pdb");
for(i=0; i<pMol->nBond_Fixed; i++) {
int ret=0;
pMol->Geo_Fix_r0[i].pMol = pMol;
ret =nlopt_add_equality_constraint(opt_AugLag, Geo_Constraint_Bond, &(pMol->Geo_Fix_r0[i]), 2.0E-6);
printf(" Fixing bond %d\n", i );
}
for(i=0; i<pMol->nAngle_Fixed; i++) {
int ret=0;
pMol->Geo_Fix_theta0[i].pMol = pMol;
ret=nlopt_add_equality_constraint(opt_AugLag, Geo_Constraint_Angle, &(pMol->Geo_Fix_theta0[i]), 2.0E-6);
printf(" Fixing angle %d\n", i );
}
for(i=0; i<pMol->nPhi_Fixed; i++) {
int ret=0;
pMol->Geo_Fix_phi0[i].pMol = pMol;
ret=nlopt_add_equality_constraint(opt_AugLag, Geo_Constraint_Dihedral, &(pMol->Geo_Fix_phi0[i]), 2.0E-6);
printf(" Fixing phi %d : %d\n", i, ret );
}
nlopt_set_xtol_rel(opt_AugLag, 2E-7);
// opt = nlopt_create(NLOPT_LD_LBFGS_GEO, nDim);
// opt = nlopt_create(NLOPT_LN_COBYLA, nDim);
// nlopt_set_min_objective(opt, func_Geo_Opt_Constraint, pMol);
// nlopt_set_xtol_rel(opt, 1E-7);
// nlopt_set_local_optimizer(opt_AugLag, opt);
// nlopt_destroy(opt);
for(i=0; i<nAtom; i++) {
iPos = 3*i;
x[iPos ] = pMol->x[i];
x[iPos+1] = pMol->y[i];
x[iPos+2] = pMol->z[i];
}
Iter_Opt_Constrained = 0;
Return_Opt = nlopt_optimize(opt_AugLag, x, &E_min);
if (Return_Opt < 0) {
printf("nlopt failed : %d\n", Return_Opt);
}
// else {
// printf("After constrained optimization, E = %12.6lf\n", E_min);
// }
nlopt_destroy(opt_AugLag);
printf("MM after:\t");
for(i=0; i<n_Phi; i++) {
printf("%3d %3d %3d %3d %8.4lf\n", DihList[i][0], DihList[i][1], DihList[i][2], DihList[i][3],
Mol_ESP.Query_Dihedral(DihList[i][0], DihList[i][1], DihList[i][2], DihList[i][3], 0, NULL));
}
Mol_ESP.Restrain_All_Torsions(0); // lift soft restraints on all soft dihedrals
return (pMol->Cal_E(0));
}
