bool Cosisim::initialize( const Parameters_handler* parameters, Error_messages_handler* errors ) { OPEN_DEBUG_STREAM( "cosisim.dbg" ); // Extract the parameters input by the user from the parameter handler //------------- // The "simulation" grid parameters std::string simul_grid_name = parameters->value( "Grid_Name.value" ); errors->report( simul_grid_name.empty(), "Grid_Name", "No grid selected" ); std::string property_name = parameters->value( "Property_Name.value" ); errors->report( property_name.empty(), "Property_Name", "No property name specified" ); // Get the simulation grid from the grid manager if( simul_grid_name.empty() ) return false; bool ok = geostat_utils::create( simul_grid_, simul_grid_name, "Grid_Name", errors ); if( !ok ) return false; // create a multi-realization property multireal_property_ = simul_grid_->add_multi_realization_property( property_name ); int nb_indicators = String_Op::to_number<int>( parameters->value( "Nb_Indicators.value" ) ); //------------- // The cdf parameters (# of thresholds, marginal, ...) bool categorical = String_Op::to_number<bool>( parameters->value( "Categorical_Variable_Flag.value" ) ); std::string marginal_probabilities_string = parameters->value( "Marginal_Probabilities.value" ); std::vector<double> marginal_probs = String_Op::to_numbers<double>( marginal_probabilities_string ); errors->report( marginal_probs.size() != nb_indicators, "Marginal_Probabilities", "Enter one probability value per indicator" ); if( categorical ) { // we ignore the input threshold values. The categories are numbered // from 0 to k (if there are k+1 categories). ccdf_ = new Categ_non_param_cdf<float>( marginal_probs.size() ); marginal_ = new Categ_non_param_cdf<float>( marginal_probs.size(), marginal_probs.begin() ); errors->report( !is_valid_cdf( marginal_probs.begin(), marginal_probs.end(), GsTL::discrete_variable_tag() ), "Marginal_Probabilities", "Values must be between 0 and 1 and sum up to 1" ); } else { std::vector<float> thresholds = String_Op::to_numbers<float>( parameters->value( "Thresholds.value" ) ); errors->report( !GsTL::is_sorted( thresholds.begin(), thresholds.end() ), "Thresholds", "Threshold values must be sorted in ascending order" ); ccdf_ = new Non_param_cdf<>( thresholds.begin(), thresholds.end() ); marginal_ = new Non_param_cdf<>( thresholds.begin(), thresholds.end(), marginal_probs.begin() ); errors->report( !is_valid_cdf( marginal_probs.begin(), marginal_probs.end(), GsTL::continuous_variable_tag() ), "Marginal_Probabilities", "The values entered do not define a valid cdf" ); // Set up the extrapolation tails geostat_utils::set_cdf_extrapolation_tail(parameters,errors, *((Non_param_cdf<>*) ccdf_), "lowerTailCdf", "upperTailCdf"); geostat_utils::set_cdf_extrapolation_tail(parameters,errors, *((Non_param_cdf<>*) marginal_), "lowerTailCdf", "upperTailCdf"); } //------------- // The hard data parameters std::string prim_harddata_grid_name = parameters->value( "Primary_Harddata_Grid.value" ); Geostat_grid* prim_harddata_grid = 0; Geostat_grid* sec_harddata_grid = 0; if( !prim_harddata_grid_name.empty() ) { // Get the harddata grid from the grid manager bool ok = geostat_utils::create( prim_harddata_grid, prim_harddata_grid_name, "Primary_Harddata_Grid", errors ); if( !ok ) return false; if( !dynamic_cast<Point_set*>(prim_harddata_grid) && prim_harddata_grid != simul_grid_ ) { std::ostringstream error_message; error_message << "the grid should either be the same as the simulation grid " << "or be a set of points"; errors->report( std::string( "Primary_Harddata_Grid" ), error_message.str() ); } // get the properties std::string primary_indicators_str = parameters->value( "Primary_Indicators.value" ); std::vector<std::string> primary_indicators_names = String_Op::decompose_string( primary_indicators_str, ";", false ); for( unsigned int i= 0; i < primary_indicators_names.size() ; i++ ) { primary_indicators_.push_back( prim_harddata_grid->property( primary_indicators_names[i] ) ); } if( nb_indicators != primary_indicators_names.size() ) { std::ostringstream message; message << "Specify exactly " << nb_indicators << " properties"; errors->report( std::string("Primary_Indicators"), message.str() ); } } std::string sec_harddata_grid_name = parameters->value( "Secondary_Harddata_Grid.value" ); if( !sec_harddata_grid_name.empty() ) { // Get the harddata grid from the grid manager bool ok2 = geostat_utils::create( sec_harddata_grid, sec_harddata_grid_name, "Secondary_Harddata_Grid", errors ); if( !ok2 ) return false; if( !dynamic_cast<Point_set*>( sec_harddata_grid ) && sec_harddata_grid != simul_grid_ ) { std::ostringstream error_message; error_message << "the grid should either be the same as the simulation grid " << "or be a set of points"; errors->report( std::string( "Secondary_Harddata_Grid" ), error_message.str() ); } std::string secondary_indicators_str = parameters->value( "Secondary_Indicators.value" ); errors->report( secondary_indicators_str.empty(), "Secondary_Indicators", "No property names specified" ); std::vector<std::string> secondary_indicators_names = String_Op::decompose_string( secondary_indicators_str, ";", false ); for( unsigned int i= 0; i < secondary_indicators_names.size() ; i++ ) { secondary_indicators_.push_back( sec_harddata_grid->property( secondary_indicators_names[i] ) ); } if( nb_indicators != secondary_indicators_names.size() ) { std::ostringstream message; message << "Specify exactly " << nb_indicators << " properties"; errors->report( std::string("Secondary_Indicators"), message.str() ); } } // check if errors were reported so far if( !errors->empty() ) return false; //-------------------- // Create K new properties on the simulation grid. Those are the properties // the simulation algorithm will be working on for each realization for( unsigned int j = 0 ; j < nb_indicators ; j++ ) { std::ostringstream prop_name; prop_name << "__tmp_indicator_" << j; GsTLGridProperty* prop = geostat_utils::add_property_to_grid( simul_grid_, prop_name.str() ); indicators_.push_back( prop ); } //-------------------- // Currently, we always assign the hard data to the simulation grid if( prim_harddata_grid ) { property_copier_ = Property_copier_factory::get_copier( prim_harddata_grid, simul_grid_ ); if( !property_copier_ ) { std::ostringstream message; message << "It is currently not possible to copy a property from a " << prim_harddata_grid->classname() << " to a " << simul_grid_->classname() ; errors->report( !property_copier_, "Assign_Hard_Data", message.str() ); return false; } //initializer_ = new Grid_initializer( simul_grid_, false ); for( unsigned int i = 0 ; i < primary_indicators_.size() ; i++ ) { property_copier_->copy( prim_harddata_grid, primary_indicators_[i], simul_grid_, indicators_[i] ); } } //------------- // Number of realizations and random number seed nb_of_realizations_ = String_Op::to_number<int>( parameters->value( "Nb_Realizations.value" ) ); seed_ = String_Op::to_number<int>( parameters->value( "Seed.value" ) ); //------------- // Set-up the indicator coding function if( categorical ) indicator_coder_ = Indicator<float>( new Class_indicator_function<float> ); else indicator_coder_ = Indicator<float>( new Indicator_function<float> ); //------------- // The Ik parameter (median or full) do_median_ik_ = String_Op::to_number<bool>( parameters->value( "Median_Ik_Flag.value" ) ); //------------- // The search neighborhood parameters int prim_max_neigh = String_Op::to_number<int>( parameters->value( "Max_Conditioning_Data_Primary.value" ) ); GsTLTriplet prim_ellips_ranges; GsTLTriplet prim_ellips_angles; bool prim_extract_ok = geostat_utils::extract_ellipsoid_definition( prim_ellips_ranges, prim_ellips_angles, "Search_Ellipsoid_Primary.value", parameters, errors ); if( !prim_extract_ok ) return false; GsTLTriplet sec_ellips_ranges; GsTLTriplet sec_ellips_angles; int sec_max_neigh = 0; if( sec_harddata_grid ) { sec_max_neigh = String_Op::to_number<int>( parameters->value( "Max_Conditioning_Data_Secondary.value" ) ); bool sec_extract_ok = geostat_utils::extract_ellipsoid_definition( sec_ellips_ranges, sec_ellips_angles, "Search_Ellipsoid_Secondary.value", parameters, errors ); if( !sec_extract_ok ) return false; } //------------- // Variogram (covariance) initialization // We distinguish two cases: // - median ik: there is only one covariance-set // - full ik : there are as many covariances as indicators std::vector< CovarianceType > covar_vector; std::vector<double> Bz_values; if( sec_harddata_grid ) { std::string Bz_string = parameters->value( "Bz_Values.value" ); Bz_values = String_Op::to_numbers<double>( Bz_string ); } else Bz_values.assign( nb_indicators, 0.0 ); if( do_median_ik_ ) { CovarianceType cov; bool init_cov_ok = geostat_utils::initialize_covariance( &cov, "Variogram_Median_Ik", parameters, errors ); if( !init_cov_ok ) return false; covar_vector.assign( nb_indicators, cov ); errors->report( Bz_values.empty(), "Bz_Values", "No values for Bz" ); covariances_.push_back( MarkovBayesCovariance(covar_vector[0], Bz_values[0]) ); } else { // We are doing full ik covar_vector.resize( nb_indicators ); if( Bz_values.size() != nb_indicators ) { errors->report( "Bz_Values", "Enter one Bz value per indicator" ); return false; } // initialize all the covariances bool init_cov_ok = geostat_utils::initialize_covariance( &covar_vector[0], "Variogram_Full_Ik", parameters, errors ); if( !init_cov_ok ) return false; covariances_.push_back( MarkovBayesCovariance(covar_vector[0], Bz_values[0]) ); for( int i=1; i < nb_indicators ; i++ ) { std::ostringstream tagname; tagname << "Variogram_Full_Ik_" << i+1 ; init_cov_ok = geostat_utils::initialize_covariance( &covar_vector[i], tagname.str(), parameters, errors ); if( !init_cov_ok ) return false; covariances_.push_back( MarkovBayesCovariance( covar_vector[i], Bz_values[i] ) ); } } Search_filter* prim_filter = geostat_utils:: set_advanced_search("AdvancedSearch_Primary", parameters, errors); Search_filter* soft_filter = NULL; if(sec_harddata_grid) soft_filter = geostat_utils:: set_advanced_search("AdvancedSearch_Secondary", parameters, errors); //-------------------- // neighborhoods initialization init_neighborhoods( simul_grid_, sec_harddata_grid, prim_ellips_ranges, prim_ellips_angles, sec_ellips_ranges, sec_ellips_angles, prim_max_neigh, sec_max_neigh, covar_vector, prim_filter, soft_filter ); delete prim_filter; delete soft_filter; //--------------------- // Kriging constraints and kriging combiner geostat_utils::Kriging_type ktype = geostat_utils::kriging_type( "Kriging_Type.value", parameters, errors ); if( ktype == geostat_utils::SK ) { for( int i = 0; i < nb_indicators ; i++ ) { typedef geostat_utils::WeightIterator Iter1; typedef geostat_utils::NeighIterator Iter2; typedef CoSK_combiner<Iter1,Iter2> CoSKCombiner; std::vector<double> means; // use the same mean for the primary and the secondary data: they are both // P(I(u)=1) means.assign( 2, *(marginal_->p_begin() + i) ); combiners_.push_back( geostat_utils::CoKrigingCombiner( new CoSKCombiner( means ) ) ); } Co_SKConstraints_impl< geostat_utils::NeighIterator, geostat_utils::Location > sk_constr; kconstraints_ = new geostat_utils::CoKrigingConstraints( &sk_constr ); } else { combiners_.resize( nb_indicators ); kconstraints_ = new geostat_utils::CoKrigingConstraints; } std::string region_name = parameters->value( "Grid_Name.region" ); if (!region_name.empty() && simul_grid_->region( region_name ) == NULL ) { errors->report("Grid_Name","Region "+region_name+" does not exist"); } else grid_region_.set_temporary_region( region_name, simul_grid_); if( simul_grid_ != sec_harddata_grid ) { std::string region_name = parameters->value( "Secondary_Harddata_Grid.region" ); if (!region_name.empty() && sec_harddata_grid->region( region_name ) == NULL ) { errors->report("Secondary_Harddata_Grid","Region "+region_name+" does not exist"); } else soft_grid_region_.set_temporary_region( region_name, sec_harddata_grid); } //------------------------------- // Done! if( !errors->empty() ) return false; return true; }
bool LU_sim::initialize( const Parameters_handler* parameters, Error_messages_handler* errors ) { OPEN_DEBUG_STREAM( "LU_sim.dbg" ); // Extract the parameters input by the user from the parameter handler //------------- // The "simulation" grid parameters std::string simul_grid_name = parameters->value( "Grid_Name.value" ); errors->report( simul_grid_name.empty(), "Grid_Name", "No grid selected" ); std::string property_name = parameters->value( "Property_Name.value" ); errors->report( property_name.empty(), "Property_Name", "No property name specified" ); // Get the simulation grid from the grid manager if( simul_grid_name.empty() ) return false; bool ok = geostat_utils::create( simul_grid_, simul_grid_name, "Grid_Name", errors ); if( !ok ) return false; // create a multi-realization property multireal_property_ = simul_grid_->add_multi_realization_property( property_name ); //------------- // The hard data parameters std::string harddata_grid_name = parameters->value( "Hard_Data.grid" ); if( !harddata_grid_name.empty() ) { std::string hdata_prop_name = parameters->value( "Hard_Data.property" ); errors->report( hdata_prop_name.empty(), "Hard_Data", "No property name specified" ); // Get the harddata grid from the grid manager bool ok = geostat_utils::create( harddata_grid_, harddata_grid_name, "Hard_Data", errors ); if( !ok ) return false; harddata_property_ = harddata_grid_->property( hdata_prop_name ); if( !harddata_property_ ) { std::ostringstream error_stream; error_stream << harddata_grid_name << " does not have a property called " << hdata_prop_name; errors->report( "Hard_Data", error_stream.str() ); return false; } } // hard data assignement and transform is only needed if we have a valid // hard data grid and property. We always assign the data if it belongs // the same grid bool assign_harddata = String_Op::to_number<bool>( parameters->value( "Assign_Hard_Data.value" ) ); if( harddata_grid_ == NULL ) assign_harddata=false; else if( harddata_grid_ == simul_grid_ ) assign_harddata=true; if( assign_harddata ) { property_copier_ = Property_copier_factory::get_copier( harddata_grid_, simul_grid_ ); if( !property_copier_ ) { std::ostringstream message; message << "It is currently not possible to copy a property from a " << harddata_grid_->classname() << " to a " << simul_grid_->classname() ; errors->report( !property_copier_, "Assign_Hard_Data", message.str() ); return false; } } //------------- // Target histogram use_target_hist_ = String_Op::to_number<bool>( parameters->value( "Use_Target_Histogram.value" ) ); if(use_target_hist_) { bool ok = distribution_utils::get_continuous_cdf(target_cdf_,parameters, errors, "nonParamCdf"); if(!ok) return false; if( harddata_property_ ) { harddata_property_ = distribution_utils::gaussian_transform_property( harddata_property_, target_cdf_.raw_ptr(), harddata_grid_ ); if( !harddata_property_ ) return false; clear_temp_properties_ = true; harddata_grid_->select_property( harddata_property_->name() ); } } //------------- // Number of realizations and random number seed nb_of_realizations_ = String_Op::to_number<int>( parameters->value( "Nb_Realizations.value" ) ); seed_ = String_Op::to_number<int>( parameters->value( "Seed.value" ) ); //------------- // Variogram (covariance) initialization bool init_cov_ok = geostat_utils::initialize_covariance( &covar_, "Variogram", parameters, errors ); if( !init_cov_ok ) return false; //---------------- // Report errors if any if( !errors->empty() ) { clean(); return false; } this->extract_parameters(parameters); return true; }
bool dssim::initialize( const Parameters_handler* parameters, Error_messages_handler* errors ) { OPEN_DEBUG_STREAM( "dssim.dbg" ); // Extract the parameters input by the user from the parameter handler //------------- // The "simulation" grid parameters std::string simul_grid_name = parameters->value( "Grid_Name.value" ); errors->report( simul_grid_name.empty(), "Grid_Name", "No grid selected" ); std::string property_name = parameters->value( "Property_Name.value" ); errors->report( property_name.empty(), "Property_Name", "No property name specified" ); // Get the simulation grid from the grid manager if( simul_grid_name.empty() ) return false; bool ok = geostat_utils::create( simul_grid_, simul_grid_name, "Grid_Name", errors ); if( !ok ) return false; // create a multi-realization property multireal_property_ = simul_grid_->add_multi_realization_property( property_name ); //------------- // The hard data parameters std::string harddata_grid_name = parameters->value( "Hard_Data.grid" ); if( !harddata_grid_name.empty() ) { std::string hdata_prop_name = parameters->value( "Hard_Data.property" ); errors->report( hdata_prop_name.empty(), "Hard_Data", "No property name specified" ); // Get the harddata grid from the grid manager bool ok = geostat_utils::create( harddata_grid_, harddata_grid_name, "Hard_Data", errors ); if( !ok ) return false; harddata_property_ = harddata_grid_->property( hdata_prop_name ); if( !harddata_property_ ) { std::ostringstream error_stream; error_stream << harddata_grid_name << " does not have a property called " << hdata_prop_name; errors->report( "Hard_Data", error_stream.str() ); return false; } } // hard data assignement and transform is only needed if we have a valid // hard data grid and property bool assign_harddata = String_Op::to_number<bool>( parameters->value( "Assign_Hard_Data.value" ) ); if( harddata_grid_ == NULL ) assign_harddata=false; else if( harddata_grid_ == simul_grid_ ) assign_harddata=true; if( harddata_grid_ ) { property_copier_ = Property_copier_factory::get_copier( harddata_grid_, simul_grid_ ); if( !property_copier_ ) { std::ostringstream message; message << "It is currently not possible to copy a property from a " << harddata_grid_->classname() << " to a " << simul_grid_->classname() ; errors->report( !property_copier_, "Assign_Hard_Data", message.str() ); return false; } } //------------- // Number of realizations and random number seed nb_of_realizations_ = String_Op::to_number<int>( parameters->value( "Nb_Realizations.value" ) ); seed_ = String_Op::to_number<int>( parameters->value( "Seed.value" ) ); //------------- // Variogram (covariance) initialization bool init_cov_ok = geostat_utils::initialize_covariance( &covar_, "Variogram", parameters, errors ); if( !init_cov_ok ) return false; //------------- // Set up the search neighborhood int max_neigh = String_Op::to_number<int>( parameters->value( "Max_Conditioning_Data.value" ) ); GsTLTriplet ranges; GsTLTriplet angles; bool extract_ok = geostat_utils::extract_ellipsoid_definition( ranges, angles, "Search_Ellipsoid.value", parameters, errors ); if( !extract_ok ) return false; extract_ok = geostat_utils::is_valid_range_triplet( ranges ); errors->report( !extract_ok, "Search_Ellipsoid", "Ranges must verify: major range >= " "medium range >= minor range >= 0" ); if( !extract_ok ) return false; // If the hard data are not "relocated" on the simulation grid, // use a "combined neighborhood", otherwise use a single // neighborhood if( !harddata_grid_ || assign_harddata ) { neighborhood_ = SmartPtr<Neighborhood>( simul_grid_->neighborhood( ranges, angles, &covar_ ) ); } else { Neighborhood* simul_neigh = simul_grid_->neighborhood( ranges, angles, &covar_ ); Neighborhood* harddata_neigh = harddata_grid_->neighborhood( ranges, angles, &covar_ ); harddata_neigh->max_size( max_neigh ); harddata_neigh->select_property( harddata_property_->name() ); neighborhood_ = SmartPtr<Neighborhood>( new Combined_neighborhood_dedup( harddata_neigh, simul_neigh, &covar_, false ) ); } neighborhood_->max_size( max_neigh ); //----------------- // The kriging constraints and combiner geostat_utils::KrigTagMap tags_map; tags_map[ geostat_utils::KT ] = "Trend.value"; tags_map[ geostat_utils::LVM ] = "Local_Mean_Property.value"; geostat_utils::KrigDefaultsMap defaults; defaults[ geostat_utils::SK ] = "0.0"; geostat_utils::Kriging_type ktype = geostat_utils::kriging_type( "Kriging_Type.value", parameters, errors ); if(ktype == geostat_utils::SK ) defaults[ geostat_utils::SK ] = parameters->value("SK_mean.value"); geostat_utils::initialize( ktype, combiner_, Kconstraints_, tags_map, parameters, errors, simul_grid_, defaults ); // Type and parametrization of the cdf get_cdf( parameters, errors ); //ccdf_ = get_cdf( parameters, errors ); //---------------- // Report errors if any if( !errors->empty() ) return false; return true; }