void NLPDakota::imp_calc_point(
ERequiredFunc required
,const DVectorSlice &x_full
,bool newx
,const ZeroOrderInfoSerial *zero_order_info
,const ObjGradInfoSerial *obj_grad_info
,const FirstOrderExplInfo *first_order_expl_info
) const
{
using LinAlgOpPack::Vp_StV;
typedef FirstOrderExplInfo::val_t G_val_t;
typedef FirstOrderExplInfo::ivect_t G_ivect_t;
typedef FirstOrderExplInfo::jvect_t G_jvect_t;
Cout << "\nEntering NLPDakota::imp_calc_point(...) ...\n";
// throw std::logic_error("NLPDakota::imp_calc_point(): End, dam it!");
if( newx ) {
f_orig_updated_ = false;
c_orig_updated_ = false;
h_orig_updated_ = false;
Gf_orig_updated_ = false;
Gc_orig_updated_ = false;
Gh_orig_updated_ = false;
my_vec_view(dakota_functions_) = 0.0;
}
const DVectorSlice x_orig = x_full(1,n_orig_);
//
// Determine which quantities to compute
//
const bool calc_f = ( required==CALC_F || multi_calc_ ) && !f_orig_updated_;
const bool calc_c = ( required==CALC_C || multi_calc_ ) && !c_orig_updated_;
const bool calc_h = ( required==CALC_H || multi_calc_ ) && !h_orig_updated_;
const bool calc_Gf = ( required==CALC_GF || ( (int)required >= (int)CALC_GF && multi_calc_ ) ) && !Gf_orig_updated_;
const bool calc_Gc = ( required==CALC_GC || ( (int)required >= (int)CALC_GF && multi_calc_ ) ) && !Gc_orig_updated_;
const bool calc_Gh = ( required==CALC_GH || ( (int)required >= (int)CALC_GF && multi_calc_ ) ) && !Gh_orig_updated_;
if( !calc_f && !calc_c && !calc_h && !calc_Gf && !calc_Gc && !calc_Gh )
return; // Everything is already computed at this point!
value_type *f = NULL;
DVector *c = NULL;
DVector *h = NULL;
DVector *Gf = NULL;
G_val_t *Gc_val = NULL;
G_ivect_t *Gc_ivect = NULL;
G_jvect_t *Gc_jvect = NULL;
G_val_t *Gh_val = NULL;
G_ivect_t *Gh_ivect = NULL;
G_jvect_t *Gh_jvect = NULL;
if(zero_order_info) {
if(calc_f) f = zero_order_info->f;
if(calc_c) c = zero_order_info->c;
if(calc_h) h = zero_order_info->h;
}
else if(obj_grad_info) {
if(calc_f) f = obj_grad_info->f;
if(calc_c) c = obj_grad_info->c;
if(calc_h) h = obj_grad_info->h;
if(calc_Gf) Gf = obj_grad_info->Gf;
}
else if(first_order_expl_info) {
if(calc_f) f = first_order_expl_info->f;
if(calc_c) c = first_order_expl_info->c;
if(calc_h) h = first_order_expl_info->h;
if(calc_Gf) Gf = first_order_expl_info->Gf;
if(calc_Gc) {
Gc_val = first_order_expl_info->Gc_val;
Gc_ivect = first_order_expl_info->Gc_ivect;
Gc_jvect = first_order_expl_info->Gc_jvect;
}
if(calc_Gh) {
Gh_val = first_order_expl_info->Gh_val;
Gh_ivect = first_order_expl_info->Gh_ivect;
Gh_jvect = first_order_expl_info->Gh_jvect;
}
}
else {
THROW_EXCEPTION(
!(zero_order_info || obj_grad_info || first_order_expl_info), std::logic_error
,"NLPDakota::imp_calc_point(): Error!"
);
}
//
// Set the Dakota active-set vector.
//
// Dakota sorts the responce functions as general inequalities first
// and general equalities second.
//
std::fill_n( &dakota_asv_[0], dakota_asv_.length(), 0 );
const int num_obj_funcs = multi_obj_weights_.length();
if( calc_f || calc_Gf ) {
std::fill_n(
&dakota_asv_[0], num_obj_funcs
,(calc_f ? 1 : 0) + (calc_Gf ? 2 : 0)
);
}
if( ( calc_c || calc_Gc ) && num_nonlin_eq_ ) {
std::fill_n(
&dakota_asv_[num_obj_funcs + num_nonlin_ineq_], num_nonlin_eq_
,(calc_c ? 1 : 0) + (calc_Gc ? 2 : 0)
);
}
if( ( calc_h || calc_Gh ) && num_nonlin_ineq_ ) {
std::fill_n(
&dakota_asv_[num_obj_funcs], num_nonlin_ineq_
,(calc_h ? 1 : 0) + (calc_Gh ? 2 : 0)
);
}
//
// Compute the nonlinear functions
//
my_vec_view(dakota_x_) = x_orig;
model_->continuous_variables(dakota_x_);
model_->compute_response(dakota_asv_);
const Dakota::Response& local_response = model_->current_response();
const Dakota::RealVector& local_function_values = local_response.function_values();
const Dakota::RealMatrix& local_function_gradients = local_response.function_gradients();
// Look for failed response
const bool eval_failed = (local_function_values[0] == dakota_failed_value_);
//
// Map to the NLP objects
//
if(!eval_failed) {
//
// The evaluation succeeded so copy the values
//
// f, Gf
if(calc_f) *f = 0.0;
if(calc_Gf) *Gf = 0.0;
for( int i = 0; i < num_obj_funcs; ++i ) {
if(calc_f) {
*f += multi_obj_weights_[i] * local_function_values[i];
dakota_functions_[i] = local_function_values[i]; // Save in dakota_functions
}
if(calc_Gf) {
Vp_StV(
&(*Gf)(1,n_orig_), multi_obj_weights_[i]
,DVectorSlice(&const_cast<Dakota::RealMatrix&>(local_function_gradients)[i][0],n_orig_)
);
}
}
if(calc_Gf && Gf->dim() > n_orig_ )
(*Gf)(n_orig_+1,Gf->dim()) = 0.0; // Zero for slack variables
// c = [ A_lin_eq' * x - lin_eq_targ ]
// [ response(num_obj_funcs+num_nonlin_ineq+1:num_obj_funs+num_nonlin_ineq+num_nonlin_eq) - nonlin_eq_targ ]
if( calc_c ) {
if( num_lin_eq_ ) {
DVectorSlice c_lin = (*c)(1,num_lin_eq_);
V_mV( &c_lin, my_vec_view(dakota_rsqp_opt_->lin_eq_targ()) );
const Dakota::RealMatrix &lin_eq_jac = dakota_rsqp_opt_->lin_eq_jac();
for( int j = 0; j < num_lin_eq_; ++j ) {
for( int i = 0; i < n_orig_; ++i ) {
c_lin[j] += lin_eq_jac[j][i] * x_orig[i];
}
}
}
if( num_nonlin_eq_ ) {
const value_type
*nonlin_eq_ptr = &const_cast<Dakota::RealVector&>(local_function_values)[num_obj_funcs+num_nonlin_ineq_];
V_VmV(
&(*c)(num_lin_eq_+1,num_lin_eq_+num_nonlin_eq_)
,DVectorSlice(const_cast<value_type*>(nonlin_eq_ptr),num_nonlin_eq_)
,my_vec_view(dakota_rsqp_opt_->nonlin_eq_targ())
);
// Save in dakota_functions
std::copy( nonlin_eq_ptr, nonlin_eq_ptr + num_nonlin_eq_, &dakota_functions_[num_obj_funcs+num_nonlin_ineq_] );
}
}
// h = [ A_lin_ineq' * x ]
// [ response(num_obj_funcs+1:num_obj_funs+num_lin_eq) ]
if( calc_h ) {
//
if( num_lin_ineq_ ) {
DVectorSlice h_lin = (*h)(1,num_lin_ineq_);
const Dakota::RealMatrix &lin_ineq_jac = dakota_rsqp_opt_->lin_ineq_jac();
for( int j = 0; j < num_lin_ineq_; ++j ) {
for( int i = 0; i < n_orig_; ++i ) {
h_lin[j] += lin_ineq_jac[j][i] * x_orig[i];
}
}
}
//
if( num_nonlin_ineq_ ) {
const value_type
*nonlin_ineq_ptr = &const_cast<Dakota::RealVector&>(local_function_values)[num_obj_funcs];
(*h)(num_lin_ineq_+1,num_lin_ineq_+num_nonlin_ineq_)
= DVectorSlice(const_cast<value_type*>(nonlin_ineq_ptr),num_nonlin_ineq_);
// Save in dakota_functions
std::copy( nonlin_ineq_ptr, nonlin_ineq_ptr + num_nonlin_ineq_, &dakota_functions_[num_obj_funcs] );
}
}
// Gc = [ A_lin_eq' ]
// [ response.grad[num_nonlin_ineq+1]' ]
// [ .. ]
// [ response.grad[num_nonlin_ineq+num_nonlin_eq]' ]
if( calc_Gc ) {
index_type nz = 0;
if( num_lin_eq_ ) {
const Dakota::RealMatrix &lin_eq_jac = dakota_rsqp_opt_->lin_eq_jac();
for( int j = 1; j <= num_lin_eq_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gc_val)[nz] = lin_eq_jac[j-1][i-1];
(*Gc_ivect)[nz] = i;
(*Gc_jvect)[nz] = j;
++nz;
}
}
}
if( num_nonlin_eq_ ) {
for( int j = 1; j <= num_nonlin_eq_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gc_val)[nz] = local_function_gradients[num_obj_funcs+num_nonlin_ineq_+j-1][i-1];
(*Gc_ivect)[nz] = i;
(*Gc_jvect)[nz] = j + num_lin_eq_;
++nz;
}
}
}
}
// Gh = [ A_lin_ineq' ]
// [ response.grad[1]' ]
// [ .. ]
// [ response.grad[num_nonlin_eq]' ]
if( calc_Gh ) {
index_type nz = 0;
if( num_lin_ineq_ ) {
const Dakota::RealMatrix &lin_ineq_jac = dakota_rsqp_opt_->lin_ineq_jac();
for( int j = 1; j <= num_lin_ineq_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gh_val)[nz] = lin_ineq_jac[j-1][i-1];
(*Gh_ivect)[nz] = i;
(*Gh_jvect)[nz] = j;
++nz;
}
}
}
if( num_nonlin_ineq_ ) {
for( int j = 1; j <= num_nonlin_ineq_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gh_val)[nz] = local_function_gradients[num_obj_funcs+j-1][i-1];
(*Gh_ivect)[nz] = i;
(*Gh_jvect)[nz] = j;
++nz;
}
}
}
}
}
else {
//
// The evaluation failed so just fill everything with
// and invalid number that will trigger a back tracking
//
// f, Gf
if(calc_f) *f = invalid_func_value_;
if(calc_Gf) *Gf = invalid_func_value_;
// c
if(calc_c) *c = invalid_func_value_;
// h
if(calc_h) *h = invalid_func_value_;
// Gc
if(calc_Gc) {
index_type nz = 0;
for( int j = 1; j <= m_orig_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gc_val)[nz] = invalid_func_value_;
(*Gc_ivect)[nz] = i;
(*Gc_jvect)[nz] = j;
++nz;
}
}
}
// Gh
if( calc_Gh ) {
index_type nz = 0;
for( int j = 1; j <= mI_orig_; ++j ) {
for( int i = 1; i <= n_orig_; ++i ) {
(*Gh_val)[nz] = invalid_func_value_;
(*Gh_ivect)[nz] = i;
(*Gh_jvect)[nz] = j;
++nz;
}
}
}
}
if(calc_f) f_orig_updated_ = true;
if(calc_c) c_orig_updated_ = true;
if(calc_h) h_orig_updated_ = true;
if(calc_Gf) Gf_orig_updated_ = true;
if(calc_Gc) Gc_orig_updated_ = true;
if(calc_Gh) Gh_orig_updated_ = true;
}
