int Cosisim::execute( GsTL_project* ) { // Initialize the global random number generator Global_random_number_generator::instance()->seed( seed_ ); // Set up a progress notifier int total_steps = simul_grid_->size() * (nb_of_realizations_); int frequency = std::max( total_steps / 20, 1 ); SmartPtr<Progress_notifier> progress_notifier = utils::create_notifier( "Running CoSisim", total_steps, frequency ); simul_grid_->init_random_path(); // loop on all realizations for( int nreal = 0; nreal < nb_of_realizations_ ; nreal ++ ) { // update the progress notifier progress_notifier->message() << "working on realization " << nreal+1 << gstlIO::end; if( !progress_notifier->notify() ) return 1; // Create a new property to hold the realization and tell the simulation // grid to use it as the current property appli_message( "Creating new realization" ); Grid_continuous_property* prop = multireal_property_->new_realization(); prop->set_parameters(parameters_); simul_grid_->select_property( prop->name() ); typedef Geostat_grid::random_path_iterator RandomPathIterator; RandomPathIterator path_begin = simul_grid_->random_path_begin(); RandomPathIterator path_end = simul_grid_->random_path_end(); int status = 0; if( do_median_ik_ ) status = median_ik( path_begin, path_end, progress_notifier.raw_ptr() ); else status = full_ik( path_begin, path_end, progress_notifier.raw_ptr() ); reset_indicator_properties(); // check if the simulation was aborted if( status == 1 ) { clean( prop ); return 1; } } // end loop on realizations remove_temporary_properties(); return 0; }
void PostKriging::initialize_operation(std::vector<Grid_continuous_property*>& props, std::vector<float>& vals,Error_messages_handler* errors, const Parameters_handler* parameters, std::string tag) { std::string base_prop_name = parameters->value( tag+"_prop.value" ); errors->report(base_prop_name.empty(), tag+"_prop", "No name specified" ); std::string val_names = parameters->value( tag+"_vals.value" ); errors->report( val_names.empty(), tag+"_vals", "No values specified" ); if( errors->empty() ) { vals = String_Op::to_numbers<float>(val_names); for(std::vector< float >::iterator it = vals.begin();it != vals.end(); ++it ) { std::ostringstream prop_name; prop_name << base_prop_name <<"_tr"<< *it; Grid_continuous_property* prop = geostat_utils::add_property_to_grid( grid_,prop_name.str() ); prop->set_parameters(parameters_); props.push_back(prop); } } }
int LU_sim::execute( GsTL_project* ) { // Initialize the global random number generator Global_random_number_generator::instance()->seed( seed_ ); // Set up a progress notifier int total_steps = simul_grid_->size() * (nb_of_realizations_); int frequency = std::max( total_steps / 20, 1 ); SmartPtr<Progress_notifier> progress_notifier = utils::create_notifier( "Running LU_sim", total_steps, frequency ); // In LU simulation, the marginal is a Gaussian cdf, // with mean 0 and variance 1. Gaussian_cdf marginal( 0.0, 1.0 ); //typedef Geostat_grid::random_path_iterator iterator; typedef Gval_iterator< TabularMapIndex > iterator; std::vector< int > id_unknown; std::vector< int > id_data; //harddata_grid_->select_property(harddata_property_->name()); if( harddata_grid_ ) { for( int i=0; i< harddata_property_->size(); i++ ) { if(!harddata_property_->is_informed(i) ) continue; id_data.push_back( i ); } } for( int i=0; i< simul_grid_->size(); i++ ) { if( simul_grid_ == harddata_grid_ && harddata_property_->is_informed(i) ) continue; id_unknown.push_back( i ); } iterator begin_d( harddata_grid_, harddata_property_ ,0, id_data.size(), TabularMapIndex(&id_data) ); iterator end_d( harddata_grid_, harddata_property_ ,id_data.size(), id_data.size(), TabularMapIndex(&id_data) ); Grid_continuous_property* prop = multireal_property_->new_realization(); iterator begin_u( simul_grid_, prop ,0, id_unknown.size(), TabularMapIndex(&id_unknown) ); iterator end_u( simul_grid_, prop ,id_unknown.size(), id_unknown.size(), TabularMapIndex(&id_unknown) ); Random_number_generator gen; LU_simulator< Covariance<Location>, Random_number_generator, Geostat_grid> lu_sim( covar_,gen, simul_grid_ ); lu_sim.initialize_matrix(begin_u, end_u, begin_d, end_d); // loop on all realizations for( int nreal = 0; nreal < nb_of_realizations_ ; nreal ++ ) { // update the progress notifier progress_notifier->message() << "working on realization " << nreal+1 << gstlIO::end; if( !progress_notifier->notify() ) return 1; // Create a new property to hold the realization and tell the simulation // grid to use it as the current property appli_message( "Creating new realization" ); //Grid_continuous_property* prop = multireal_property_->new_realization(); if(nreal>0) prop = multireal_property_->new_realization(); prop->set_parameters(parameters_); simul_grid_->select_property( prop->name() ); // initialize the new realization with the hard data, if that was requested if( property_copier_ ) { property_copier_->copy( harddata_grid_, harddata_property_, simul_grid_, prop ); } iterator begin_unk( simul_grid_, prop ,0, id_unknown.size(), TabularMapIndex(&id_unknown) ); iterator end_unk( simul_grid_, prop ,id_unknown.size(), id_unknown.size(), TabularMapIndex(&id_unknown) ); int status = lu_sim(begin_unk,end_unk,marginal); // initialize the new realization with the hard data, if that was requested // if( property_copier_ ) { // property_copier_->copy( harddata_grid_, harddata_property_, // simul_grid_, prop ); //initializer_->assign( prop, harddata_grid_, harddata_property_->name() ); // } if( status == -1 ) { clean( prop ); return 1; } // back-transform if needed if( use_target_hist_ ) { cdf_transform( prop->begin(), prop->end(), marginal, *target_cdf_.raw_ptr() ); } } clean(); return 0; }
int Indicator_kriging::full_ik( Progress_notifier* progress_notifier ) { bool ok = true; bool order_relation_problems = false; // create all the properties we will populate std::vector< Grid_continuous_property* > simul_properties; for( int thres = 0; thres < thres_count_; thres++ ) { Grid_continuous_property* prop = multireal_property_->new_realization(); prop->set_parameters(parameters_); simul_properties.push_back( prop ); } std::vector<double> krig_weights; SK_constraints Kconstraints; typedef std::vector<double>::const_iterator weight_iterator; typedef SK_combiner< weight_iterator, Neighborhood > SKCombiner; // the following line could probably be omitted simul_grid_->select_property( simul_properties[0]->name() ); Geostat_grid::iterator begin = simul_grid_->begin(); Geostat_grid::iterator end = simul_grid_->end(); // loop over the grid for( ; begin != end; ++begin ) { if( !progress_notifier->notify() ) return 1; if( begin->is_informed() ) continue; // for each threshold / class: Non_parametric_cdf<float>::p_iterator p_it = ccdf_->p_begin(); for( int thres = 0; thres < thres_count_; thres++, ++p_it ) { neighborhoods_vector_[thres]->find_neighbors( *begin ); if( neighborhoods_vector_[thres]->is_empty() ){ //if we don't have any conditioning data, use the marginal *p_it = marginal_probs_[thres]; continue; } int status = kriging_weights( krig_weights, *begin, *(neighborhoods_vector_[thres].raw_ptr()), covar_vector_[thres], Kconstraints ); if( status != 0 ) { // the kriging system could not be solved, issue a warning and skip the // node ok = false; *p_it = marginal_probs_[thres]; continue; } SKCombiner combiner( marginal_probs_[thres] ); double estimate = combiner( krig_weights.begin(), krig_weights.end(), *(neighborhoods_vector_[thres].raw_ptr()) ); *p_it = estimate; } // make sure the ccdf is a valid cdf if( !ccdf_->make_valid() ) { // there was a problem making the cdf a valid cdf: // leave the node un-estimated and set the flag so that an error will // be reported order_relation_problems = true; continue; } GsTLInt node_id = begin->node_id(); // output the ccdf probabilities to the grid properties p_it = ccdf_->p_begin(); for( int thres2 = 0; thres2 < thres_count_; thres2++, ++p_it ) { simul_properties[ thres2 ]->set_value( *p_it, node_id ); } } if( !ok ) GsTLcerr << "The kriging system could not be solved for every node\n" << gstlIO::end; if( order_relation_problems ) { GsTLcerr << "A cdf could not be estimated for all nodes because of major " << "order-relation problems (all probabilities < 0 )" << gstlIO::end; } return 0; }
int Indicator_kriging::median_ik( Progress_notifier* progress_notifier ) { bool ok = true; // create all the properties we will populate std::vector< Grid_continuous_property* > simul_properties; for( int thres = 0; thres < thres_count_; thres++ ) { Grid_continuous_property* prop = multireal_property_->new_realization(); prop->set_parameters(parameters_); simul_properties.push_back( prop ); } std::vector<double> krig_weights; SK_constraints Kconstraints; typedef std::vector<double>::const_iterator weight_iterator; typedef SK_combiner< weight_iterator, Neighborhood > SKCombiner; // the following line could probably be omitted simul_grid_->select_property( simul_properties[0]->name() ); Geostat_grid::iterator begin = simul_grid_->begin(); Geostat_grid::iterator end = simul_grid_->end(); for( ; begin != end; ++begin ) { if( !progress_notifier->notify() ) return 1; if( begin->is_informed() ) continue; neighborhood_->find_neighbors( *begin ); // if( neighborhood_->is_empty() ){ if( neighborhood_->size() < min_neigh_ ){ //if we don't have any conditioning data, skip the node continue; } else { int status = kriging_weights( krig_weights, *begin, *(neighborhood_.raw_ptr()), covar_, Kconstraints ); if(status == 0) { // the kriging system could be solved // Since we're using the same covariance and the // same neighborhood for all thresholds, we can re-use the same // weights for all thresholds GsTLInt node_id = begin->node_id(); Non_parametric_cdf<float>::p_iterator p_it = ccdf_->p_begin(); for( int thres = 0; thres < thres_count_; thres++, ++p_it ) { // tell the neighbors to work on the correct property for( Neighborhood::iterator it = neighborhood_->begin(); it != neighborhood_->end(); it++ ) { it->set_property_array( hdata_properties_[ thres ] ); } SKCombiner combiner( marginal_probs_[thres] ); double estimate = combiner( krig_weights.begin(), krig_weights.end(), *(neighborhood_.raw_ptr()) ); *p_it = estimate; } // make sure the ccdf is a valid cdf ccdf_->make_valid(); // output the ccdf probabilities to the grid properties p_it = ccdf_->p_begin(); for( int thres2 = 0; thres2 < thres_count_; thres2++, ++p_it ) { simul_properties[ thres2 ]->set_value( *p_it, node_id ); } } else { // the kriging system could not be solved, issue a warning and skip the // node ok = false; } } } if( !ok ) GsTLcerr << "The kriging system could not be solved for every node\n" << gstlIO::end; return 0; }
int dssim::execute( GsTL_project* ) { // Initialize the global random number generator Global_random_number_generator::instance()->seed( seed_ ); // Set up a progress notifier int total_steps = simul_grid_->size() * (nb_of_realizations_); int frequency = std::max( total_steps / 20, 1 ); SmartPtr<Progress_notifier> progress_notifier = utils::create_notifier( "Running dssim", total_steps, frequency ); // Initialize the marginal cdf for the direct sequential simulation // LogNormal_cdf marginal( 0.1, 1.0 ); // LogNormal_cdf ccdf; // set up the cdf-estimator typedef First2_moments_cdf_Kestimator< Covariance<Location>, Neighborhood, geostat_utils::KrigingConstraints > Kriging_cdf_estimator; Kriging_cdf_estimator cdf_estimator( covar_, *Kconstraints_, *combiner_ ); // set up the sampler Random_number_generator gen; Monte_carlo_sampler_t< Random_number_generator > sampler( gen ); // compute the random path Grid_path path(simul_grid_, simul_grid_->selected_property(), target_grid_region_); //simul_grid_->init_random_path(); // loop on all realizations for( int nreal = 0; nreal < nb_of_realizations_ ; nreal ++ ) { // update the progress notifier progress_notifier->message() << "working on realization " << nreal+1 << gstlIO::end; if( !progress_notifier->notify() ) return 1; // Create a new property to hold the realization and tell the simulation // grid to use it as the current property appli_message( "Creating new realization" ); Grid_continuous_property* prop = multireal_property_->new_realization(); prop->set_parameters(parameters_); simul_grid_->select_property( prop->name() ); neighborhood_->select_property( prop->name() ); // initialize the new realization with the hard data, if that was requested if( property_copier_ ) { property_copier_->copy( harddata_grid_, harddata_property_, simul_grid_, prop ); //initializer_->assign( prop, harddata_grid_, harddata_property_->name() ); } path.randomize(); path.set_property(prop->name()); appli_message( "Doing simulation" ); // do the simulation int status = sequential_simulation( path.begin(), path.end(), *(neighborhood_.raw_ptr()), *ccdf_, cdf_estimator, *marginal_, sampler, progress_notifier.raw_ptr() ); if( status == -1 ) { clean( prop ); return 1; } } clean(); return 0; }