/*---------------------------------------------------------*/
void NOMAD::Barrier::insert ( const NOMAD::Eval_Point & x )
{
// we compare the eval types (_SGTE_ or _TRUTH_) of x and *this:
if ( x.get_eval_type() != _eval_type )
throw Barrier::Insert_Error ( "Barrier.cpp" , __LINE__ ,
"insertion of an Eval_Point into the bad Barrier object" );
// basic check:
if ( !x.is_eval_ok() )
{
_one_eval_succ = NOMAD::UNSUCCESSFUL;
return;
}
// pre-filter: if tag(x) is already in the pre-filter,
// then return _UNSUCCESSFUL_:
size_t size_before = _prefilter.size();
_prefilter.insert ( x.get_tag() );
if ( _prefilter.size() == size_before )
{
_one_eval_succ = NOMAD::UNSUCCESSFUL;
return;
}
// insertion in _all_inserted:
_all_inserted.push_back ( &x );
// other checks:
const NOMAD::Double & h = x.get_h();
if ( !x.is_EB_ok () ||
!x.get_f().is_defined () ||
!h.is_defined () ||
h.value() > _h_max.value() )
{
_one_eval_succ = NOMAD::UNSUCCESSFUL;
return;
}
// insert_feasible or insert_infeasible:
_one_eval_succ = ( x.is_feasible ( _p.get_h_min() ) ) ?
insert_feasible ( x ) : insert_infeasible(x);
if ( _one_eval_succ > _success )
_success = _one_eval_succ;
}
/*-----------------------------------------------------------*/
void NOMAD::LH_Search::search ( NOMAD::Mads & mads ,
int & nb_search_pts ,
bool & stop ,
NOMAD::stop_type & stop_reason ,
NOMAD::success_type & success ,
bool & count_search ,
const NOMAD::Eval_Point *& new_feas_inc ,
const NOMAD::Eval_Point *& new_infeas_inc )
{
new_feas_inc = new_infeas_inc = NULL;
nb_search_pts = 0;
success = NOMAD::UNSUCCESSFUL;
count_search = !stop;
if ( stop )
return;
// initial display:
const NOMAD::Display & out = _p.out();
NOMAD::dd_type display_degree = out.get_search_dd();
if ( display_degree == NOMAD::FULL_DISPLAY )
{
std::ostringstream oss;
oss << NOMAD::LH_SEARCH;
out << std::endl << NOMAD::open_block ( oss.str() ) << std::endl;
}
// active barrier:
const NOMAD::Barrier & barrier = mads.get_active_barrier();
// Evaluator_Control:
NOMAD::Evaluator_Control & ev_control = mads.get_evaluator_control();
// current incumbents:
const NOMAD::Eval_Point * feas_inc = barrier.get_best_feasible ();
const NOMAD::Eval_Point * infeas_inc = barrier.get_best_infeasible();
// get a reference point and a signature:
const NOMAD::Eval_Point * ref = (feas_inc) ? feas_inc : infeas_inc;
NOMAD::Signature * signature = _p.get_signature();
// check the number of points:
int p = _initial_search ? _p.get_LH_search_p0() : _p.get_LH_search_pi();
if ( p <= 0 )
{
if ( display_degree == NOMAD::FULL_DISPLAY )
{
std::ostringstream oss;
oss << "end of LH " << ( _initial_search ? "initial " : "")
<< "search (number of points <= 0)";
out << std::endl << NOMAD::close_block ( oss.str() ) << std::endl;
}
return;
}
// no reference point is available (we consider the standard signature):
if ( !ref )
{
// it is not sufficient with categorical variables:
if ( signature->has_categorical() )
{
if ( display_degree == NOMAD::FULL_DISPLAY )
{
std::ostringstream oss;
oss << "end of LH " << ( _initial_search ? "initial " : "")
<< "search (no available reference point)";
out << std::endl << NOMAD::close_block ( oss.str() ) << std::endl;
}
return;
}
}
else
signature = ref->get_signature();
// Change Display stats style
const std::list<std::string> old_ds = _p.get_display_stats();
std::list<std::string> ds = old_ds;
ds.push_back ( " (LH)" );
_p.set_DISPLAY_STATS ( ds );
// check the parameters:
_p.check ( false , // remove_history_file = false
false , // remove_solution_file = false
false ); // remove_stats_file = false
int i;
NOMAD::Eval_Point * x;
int n = signature->get_n();
int m = _p.get_bb_nb_outputs();
int pm1 = p-1;
// mesh size:
NOMAD::Point delta_max = signature->get_mesh()->get_delta_max ();
NOMAD::Double delta_i;
NOMAD::Point delta;
if ( !_initial_search )
signature->get_mesh()->get_delta ( delta );
// fixed variables:
const NOMAD::Point & fixed_variables = signature->get_fixed_variables();
// bb input types:
const std::vector<NOMAD::bb_input_type> & bbit = signature->get_input_types();
// bounds:
const NOMAD::Point & lb = signature->get_lb();
const NOMAD::Point & ub = signature->get_ub();
// pts contains n points of dimension p: each of these points contains
// p different values for each variable:
NOMAD::Point ** pts = new NOMAD::Point * [n];
// creation of p search points:
for ( int k = 0 ; k < p ; ++k )
{
x = new NOMAD::Eval_Point ( n , m );
x->set_signature ( signature );
for ( i = 0 ; i < n ; ++i )
{
if ( k==0 )
{
if ( fixed_variables[i].is_defined() )
pts[i] = new NOMAD::Point ( p , fixed_variables[i] );
else if ( bbit[i] == NOMAD::CATEGORICAL )
{
pts[i] = new NOMAD::Point ( p , (*ref)[i] );
}
else
{
pts[i] = new NOMAD::Point ( p );
if ( !_initial_search )
delta_i = delta[i];
values_for_var_i ( p ,
delta_i ,
delta_max[i] ,
bbit [i] ,
lb [i] ,
ub [i] ,
*pts [i] );
}
}
(*x)[i] = (*pts[i])[k];
if ( k == pm1 )
delete pts[i];
}
if ( display_degree == NOMAD::FULL_DISPLAY )
{
out << "LH point #" << x->get_tag()
<< ": ( ";
x->Point::display ( out , " " , 2 , NOMAD::Point::get_display_limit() );
out << " )" << std::endl;
}
// add the new point to the ordered list of search trial points:
ev_control.add_eval_point ( x ,
display_degree ,
false , // snap_to_bounds = false
NOMAD::Double() ,
NOMAD::Double() ,
NOMAD::Double() ,
NOMAD::Double() );
}
delete [] pts;
nb_search_pts = ev_control.get_nb_eval_points();
// eval_list_of_points:
// --------------------
new_feas_inc = new_infeas_inc = NULL;
ev_control.eval_list_of_points ( _type ,
mads.get_true_barrier() ,
mads.get_sgte_barrier() ,
mads.get_pareto_front() ,
stop ,
stop_reason ,
new_feas_inc ,
new_infeas_inc ,
success );
_p.get_display_stats();
// restore stats style
_p.set_DISPLAY_STATS ( old_ds );
_p.check ( false , // remove_history_file = false
false , // remove_solution_file = false
false ); // remove_stats_file = false
// final displays:
if ( display_degree == NOMAD::FULL_DISPLAY )
{
std::ostringstream oss;
oss << "end of LH search (" << success << ")";
out << std::endl << NOMAD::close_block ( oss.str() ) << std::endl;
}
}
/*-------------------------------------------------------------*/
void NOMAD::Speculative_Search::search ( NOMAD::Mads & mads ,
int & nb_search_pts ,
bool & stop ,
NOMAD::stop_type & stop_reason ,
NOMAD::success_type & success ,
bool & count_search ,
const NOMAD::Eval_Point *& new_feas_inc ,
const NOMAD::Eval_Point *& new_infeas_inc )
{
// new_feas_inc and new_infeas_inc are used as inputs,
// so do not initialize them to NULL here
nb_search_pts = 0;
success = NOMAD::UNSUCCESSFUL;
count_search = !stop;
if ( stop )
return;
const NOMAD::Display & out = _p.out();
NOMAD::dd_type display_degree = out.get_search_dd();
if ( display_degree == NOMAD::FULL_DISPLAY ) {
std::ostringstream oss;
oss << NOMAD::SPEC_SEARCH;
out << std::endl << NOMAD::open_block ( oss.str() ) << std::endl;
}
int lkm1; // l_{k-1}
int lk; // l_k
int n;
NOMAD::Signature * signature;
NOMAD::Point delta_m_k;
NOMAD::Point delta_m_km1;
NOMAD::Point factor;
NOMAD::Point xkm1;
NOMAD::Eval_Point * sk;
const NOMAD::Eval_Point * x[2];
x[0] = new_feas_inc;
x[1] = new_infeas_inc;
// Evaluator_Control:
NOMAD::Evaluator_Control & ev_control = mads.get_evaluator_control();
for ( int i = 0 ; i < 2 ; ++i ) {
if ( x[i] && x[i]->get_mesh_index() ) {
const NOMAD::Direction * dir = x[i]->get_direction();
if ( dir && ( dir->is_mads() || dir->get_type()==NOMAD::MODEL_SEARCH_DIR ) ) {
// get the x_k's signature:
signature = x[i]->get_signature();
if ( !signature )
throw NOMAD::Exception ( "Speculative_Search.cpp" , __LINE__ ,
"Speculative_Search::search(): could not get the signature" );
xkm1 = *x[i] - *dir;
lk = lkm1 = *x[i]->get_mesh_index();
NOMAD::Mesh::update ( NOMAD::FULL_SUCCESS , lk );
n = signature->get_n();
delta_m_k = NOMAD::Point ( n );
delta_m_km1 = NOMAD::Point ( n );
factor = NOMAD::Point ( n );
signature->get_mesh().get_delta_m ( delta_m_k , lk );
signature->get_mesh().get_delta_m ( delta_m_km1 , lkm1 );
// multiplicative factor: takes into account the fact that
// the direction contains \Delta^m_k:
try {
// factor = delta_m_k / delta_m_km1 :
for ( int k = 0 ; k < n ; ++k ) {
if ( delta_m_k[k].is_defined() && delta_m_km1[k].is_defined() &&
delta_m_k[k].value() != 0.0 && delta_m_km1[k].value() != 0.0 )
factor[k] = delta_m_k[k] / delta_m_km1[k];
else
factor[k] = 0.0;
}
}
catch ( NOMAD::Double::Invalid_Value & ) {
if ( display_degree == NOMAD::FULL_DISPLAY )
out << "could not compute " << _type << " point: stop" << std::endl
<< NOMAD::close_block ( "end of speculative search" );
stop = true;
stop_reason = NOMAD::MESH_PREC_REACHED;
return;
}
if ( lkm1 <= 0 )
factor *= NOMAD::Mesh::get_mesh_update_basis();
// speculative search point:
NOMAD::Direction new_dir ( n , 0.0 , dir->get_type() );
new_dir.Point::operator = ( factor * *dir );
sk = new NOMAD::Eval_Point;
sk->set ( n , _p.get_bb_nb_outputs() );
sk->set_signature ( signature );
sk->set_direction ( &new_dir );
sk->set_mesh_index ( &lk );
sk->Point::operator = ( xkm1 + new_dir );
if ( display_degree == NOMAD::FULL_DISPLAY ) {
out << "trial point #" << sk->get_tag()
<< ": ( ";
sk->Point::display ( out ," " , 2 , NOMAD::Point::get_display_limit() );
out << " )" << std::endl;
}
// add the new point to the list of search trial points:
ev_control.add_eval_point ( sk ,
display_degree ,
_p.get_snap_to_bounds() ,
NOMAD::Double() ,
NOMAD::Double() ,
NOMAD::Double() ,
NOMAD::Double() );
}
}
}
nb_search_pts = ev_control.get_nb_eval_points();
// eval_list_of_points:
// --------------------
new_feas_inc = new_infeas_inc = NULL;
ev_control.eval_list_of_points ( _type ,
mads.get_true_barrier() ,
mads.get_sgte_barrier() ,
mads.get_pareto_front() ,
stop ,
stop_reason ,
new_feas_inc ,
new_infeas_inc ,
success );
if ( display_degree == NOMAD::FULL_DISPLAY ) {
std::ostringstream oss;
oss << "end of speculative search (" << success << ")";
out << NOMAD::close_block ( oss.str() ) << std::endl;
}
}
/*-------------------------------------------------------------------*/
bool NOMAD::Evaluator::eval_x ( NOMAD::Eval_Point & x ,
const NOMAD::Double & h_max ,
bool & count_eval ) const
{
count_eval = false;
if ( _bb_exe.empty() || !x.is_complete() )
throw NOMAD::Exception ( "Evaluator.cpp" , __LINE__ ,
"Evaluator: no BB_EXE is defined (blackbox executable names)" );
bool sgte = x.get_eval_type() == NOMAD::SGTE;
if ( sgte && _sgte_exe.empty() )
throw NOMAD::Exception ( "Evaluator.cpp" , __LINE__ ,
"Evaluator: no SGTE_EXE is defined (surrogate executable names)" );
int pid = NOMAD::get_pid();
int seed = _p.get_seed();
std::string tmp_dir = _p.get_tmp_dir();
std::ostringstream oss;
oss << "." << seed;
if ( pid != seed )
oss << "." << pid;
oss << "." << x.get_tag() << ".";
const std::string & sint = oss.str();
// for the parallel version: no need to include the process rank in the names
// as the point tags are unique for all the processes: each process creates
// its own points and uses Eval_Point::set_tag()
// blackbox input file writing:
// ----------------------------
std::string bb_input_file_name =
tmp_dir + NOMAD::BLACKBOX_INPUT_FILE_PREFIX
+ sint + NOMAD::BLACKBOX_INPUT_FILE_EXT;
std::string bb_output_file_name =
tmp_dir + NOMAD::BLACKBOX_OUTPUT_FILE_PREFIX
+ sint + NOMAD::BLACKBOX_OUTPUT_FILE_EXT;
std::ofstream fout ( bb_input_file_name.c_str() );
if ( fout.fail() )
{
std::string err = "could not create file blackbox input file " + bb_input_file_name + ". \n \n #### Please check that write permission are granted for the working directory. #### ";
throw NOMAD::Exception ( "Evaluator.cpp" , __LINE__ , err );
}
// include seed:
if ( _p.get_bb_input_include_seed() )
fout << seed << " ";
// include tag:
if ( _p.get_bb_input_include_tag() )
fout << x.get_tag() << " ";
fout.setf ( std::ios::fixed );
fout.precision ( NOMAD::DISPLAY_PRECISION_BB );
x.Point::display ( fout , " " , -1 , -1 );
fout << std::endl;
fout.close();
if ( fout.fail() )
return false;
x.set_eval_status ( NOMAD::EVAL_IN_PROGRESS );
std::string cmd , bb_exe;
std::ifstream fin;
bool failed;
NOMAD::Double d;
int j , nbbok;
int ibbo = 0;
// system call to evaluate the blackbox:
// -------------------------------------
size_t bn = _bb_exe.size();
for ( size_t k = 0 ; k < bn ; ++k )
{
// executable name:
bb_exe = ( sgte ) ? _sgte_exe[k] : _bb_exe[k];
// system command:
cmd = bb_exe + " " + bb_input_file_name;
// redirection ? if no, the blackbox has to create
// the output file 'bb_output_file_name':
if ( _p.get_bb_redirection() )
cmd += " > " + bb_output_file_name;
#ifdef DEBUG
#ifdef USE_MPI
int rank;
MPI_Comm_rank ( MPI_COMM_WORLD, &rank);
_p.out() << "command(rank=" << rank
<< ") = \'" << cmd << "\'" << std::endl;
#else
_p.out() << "command=\'" << cmd << "\'" << std::endl;
#endif
#endif
// the evaluation:
{
int signal = system ( cmd.c_str() );
// catch the ctrl-c signal:
if ( signal == SIGINT )
raise ( SIGINT );
// other evaluation error:
failed = ( signal != 0 );
count_eval = true;
}
// the evaluation failed (we stop the evaluations):
if ( failed )
{
x.set_eval_status ( NOMAD::EVAL_FAIL );
break;
}
// reading of the blackbox output file:
// ------------------------------------
else
{
// bb-output file reading:
fin.open ( bb_output_file_name.c_str() );
failed = false;
bool is_defined = true;
bool is_inf = false;
// loop on the number of outputs for this blackbox:
nbbok = _bb_nbo[k];
for ( j = 0 ; j < nbbok ; ++j )
{
fin >> d;
if ( !d.is_defined() )
{
is_defined = false;
break;
}
if ( fin.fail() )
{
failed = true;
break;
}
if ( d.value() >= NOMAD::INF )
{
is_inf = true;
break;
}
x.set_bb_output ( ibbo++ , d );
}
fin.close();
// the evaluation failed:
if ( failed || !is_defined || is_inf )
{
x.set_eval_status ( NOMAD::EVAL_FAIL );
break;
}
// stop the evaluations if h > h_max or if a 'EB' constraint is violated:
if ( k < _bb_exe.size() - 1 && interrupt_evaluations ( x , h_max ) )
break;
}
}
if ( x.get_eval_status() == NOMAD::EVAL_IN_PROGRESS )
x.set_eval_status ( NOMAD::EVAL_OK );
// delete the blackbox input and output files:
// -------------------------------------------
remove ( bb_input_file_name.c_str () );
remove ( bb_output_file_name.c_str() );
// check the CNT_EVAL output:
// --------------------------
int index_cnt_eval = _p.get_index_cnt_eval();
if ( index_cnt_eval >= 0 && x.get_bb_outputs()[index_cnt_eval] == 0.0 )
count_eval = false;
return x.is_eval_ok();
}
