void G_math_srand(int seed)
{
G_srand48(seed);
}
int main(int argc, char *argv[])
{
char *output, buf[DB_SQL_MAX];
double (*rng)(void) = G_drand48;
double zmin, zmax;
int seed;
int i, j, k, n, type, usefloat;
int area, nareas, field;
struct boxlist *List = NULL;
BOX_SIZE *size_list = NULL;
int alloc_size_list = 0;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct cat_list *cat_list;
struct bound_box box;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *field, *cats, *where, *output, *nsites,
*zmin, *zmax, *zcol, *ztype, *seed;
} parm;
struct
{
struct Flag *z, *notopo, *a;
} flag;
struct field_info *Fi;
dbDriver *driver;
dbTable *table;
dbString sql;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("sampling"));
G_add_keyword(_("statistics"));
G_add_keyword(_("random"));
module->description = _("Generates random 2D/3D vector points.");
parm.output = G_define_standard_option(G_OPT_V_OUTPUT);
parm.nsites = G_define_option();
parm.nsites->key = "n";
parm.nsites->type = TYPE_INTEGER;
parm.nsites->required = YES;
parm.nsites->description = _("Number of points to be created");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.input->required = NO;
parm.input->description = _("Restrict points to areas in input vector");
parm.input->guisection = _("Selection");
parm.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
parm.field->guisection = _("Selection");
parm.cats = G_define_standard_option(G_OPT_V_CATS);
parm.cats->guisection = _("Selection");
parm.where = G_define_standard_option(G_OPT_DB_WHERE);
parm.where->guisection = _("Selection");
parm.zmin = G_define_option();
parm.zmin->key = "zmin";
parm.zmin->type = TYPE_DOUBLE;
parm.zmin->required = NO;
parm.zmin->description =
_("Minimum z height (needs -z flag or column name)");
parm.zmin->answer = "0.0";
parm.zmin->guisection = _("3D output");
parm.zmax = G_define_option();
parm.zmax->key = "zmax";
parm.zmax->type = TYPE_DOUBLE;
parm.zmax->required = NO;
parm.zmax->description =
_("Maximum z height (needs -z flag or column name)");
parm.zmax->answer = "0.0";
parm.zmax->guisection = _("3D output");
parm.seed = G_define_option();
parm.seed->key = "seed";
parm.seed->type = TYPE_INTEGER;
parm.seed->required = NO;
parm.seed->description =
_("The seed to initialize the random generator. If not set the process ID is used");
parm.zcol = G_define_standard_option(G_OPT_DB_COLUMN);
parm.zcol->label = _("Name of column for z values");
parm.zcol->description =
_("Writes z values to column");
parm.zcol->guisection = _("3D output");
parm.ztype = G_define_option();
parm.ztype->key = "column_type";
parm.ztype->type = TYPE_STRING;
parm.ztype->required = NO;
parm.ztype->multiple = NO;
parm.ztype->description = _("Type of column for z values");
parm.ztype->options = "integer,double precision";
parm.ztype->answer = "double precision";
parm.ztype->guisection = _("3D output");
flag.z = G_define_flag();
flag.z->key = 'z';
flag.z->description = _("Create 3D output");
flag.z->guisection = _("3D output");
flag.a = G_define_flag();
flag.a->key = 'a';
flag.a->description = _("Generate n points for each individual area");
flag.notopo = G_define_standard_flag(G_FLG_V_TOPO);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
output = parm.output->answer;
n = atoi(parm.nsites->answer);
if(parm.seed->answer)
seed = atoi(parm.seed->answer);
if (n <= 0) {
G_fatal_error(_("Number of points must be > 0 (%d given)"), n);
}
nareas = 0;
cat_list = NULL;
field = -1;
if (parm.input->answer) {
Vect_set_open_level(2); /* topology required */
if (2 > Vect_open_old2(&In, parm.input->answer, "", parm.field->answer))
G_fatal_error(_("Unable to open vector map <%s>"),
parm.input->answer);
if (parm.field->answer)
field = Vect_get_field_number(&In, parm.field->answer);
if ((parm.cats->answer || parm.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). Parameter '%s' or '%s' specified, assuming layer '1'."),
field, parm.cats->key, parm.where->key);
field = 1;
}
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, parm.where->answer,
parm.cats->answer);
nareas = Vect_get_num_areas(&In);
if (nareas == 0) {
Vect_close(&In);
G_fatal_error(_("No areas in vector map <%s>"), parm.input->answer);
}
}
else {
if (flag.a->answer)
G_fatal_error(_("The <-%c> flag requires an input vector with areas"),
flag.a->key);
}
/* create new vector map */
if (-1 == Vect_open_new(&Out, output, flag.z->answer ? WITH_Z : WITHOUT_Z))
G_fatal_error(_("Unable to create vector map <%s>"), output);
Vect_set_error_handler_io(NULL, &Out);
/* Do we need to write random values into attribute table? */
usefloat = -1;
if (parm.zcol->answer) {
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database, &Out));
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Out), Fi->driver);
}
db_set_error_handler_driver(driver);
db_begin_transaction(driver);
db_init_string(&sql);
sprintf(buf, "create table %s (%s integer, %s %s)", Fi->table, GV_KEY_COLUMN,
parm.zcol->answer, parm.ztype->answer);
db_set_string(&sql, buf);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* Create table */
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to create table: %s"),
db_get_string(&sql));
}
/* Create index */
if (db_create_index2(driver, Fi->table, Fi->key) != DB_OK)
G_warning(_("Unable to create index"));
/* Grant */
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK) {
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
}
/* OK. Let's check what type of column user has created */
db_set_string(&sql, Fi->table);
if (db_describe_table(driver, &sql, &table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
if (db_get_table_number_of_columns(table) != 2) {
G_fatal_error(_("Table should contain only two columns"));
}
type = db_get_column_sqltype(db_get_table_column(table, 1));
if (type == DB_SQL_TYPE_SMALLINT || type == DB_SQL_TYPE_INTEGER)
usefloat = 0;
if (type == DB_SQL_TYPE_REAL || type == DB_SQL_TYPE_DOUBLE_PRECISION)
usefloat = 1;
if (usefloat < 0) {
G_fatal_error(_("You have created unsupported column type. This module supports only INTEGER"
" and DOUBLE PRECISION column types."));
}
}
Vect_hist_command(&Out);
/* Init the random seed */
if(parm.seed->answer)
G_srand48(seed);
else
G_srand48_auto();
G_get_window(&window);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (nareas > 0) {
int first = 1, count;
struct bound_box abox, bbox;
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
count = 0;
for (i = 1; i <= nareas; i++) {
if (!Vect_get_area_centroid(&In, i))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, i, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list))
continue;
}
Vect_get_area_box(&In, i, &abox);
if (!Vect_box_overlap(&abox, &box))
continue;
if (first) {
Vect_box_copy(&bbox, &abox);
first = 0;
}
else
Vect_box_extend(&bbox, &abox);
count++;
}
if (count == 0) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Selected areas in input vector <%s> do not overlap with the current region"),
parm.input->answer);
}
Vect_box_copy(&box, &bbox);
/* does the vector overlap with the current region ? */
if (box.W >= window.east || box.E <= window.west ||
box.S >= window.north || box.N <= window.south) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Input vector <%s> does not overlap with the current region"),
parm.input->answer);
}
/* try to reduce the current region */
if (window.east > box.E)
window.east = box.E;
if (window.west < box.W)
window.west = box.W;
if (window.north > box.N)
window.north = box.N;
if (window.south < box.S)
window.south = box.S;
List = Vect_new_boxlist(1);
alloc_size_list = 10;
size_list = G_malloc(alloc_size_list * sizeof(BOX_SIZE));
}
zmin = zmax = 0;
if (flag.z->answer || parm.zcol->answer) {
zmax = atof(parm.zmax->answer);
zmin = atof(parm.zmin->answer);
}
G_message(_("Generating points..."));
if (flag.a->answer && nareas > 0) {
struct bound_box abox, bbox;
int cat = 1;
/* n points for each area */
nareas = Vect_get_num_areas(&In);
G_percent(0, nareas, 1);
for (area = 1; area <= nareas; area++) {
G_percent(area, nareas, 1);
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
Vect_get_area_box(&In, area, &abox);
if (!Vect_box_overlap(&box, &abox))
continue;
bbox = abox;
if (bbox.W < box.W)
bbox.W = box.W;
if (bbox.E > box.E)
bbox.E = box.E;
if (bbox.S < box.S)
bbox.S = box.S;
if (bbox.N > box.N)
bbox.N = box.N;
for (i = 0; i < n; ++i) {
double x, y, z;
int outside = 1;
int ret;
Vect_reset_line(Points);
Vect_reset_cats(Cats);
while (outside) {
x = rng() * (bbox.W - bbox.E) + bbox.E;
y = rng() * (bbox.N - bbox.S) + bbox.S;
z = rng() * (zmax - zmin) + zmin;
ret = Vect_point_in_area(x, y, &In, area, &abox);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
}
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, cat++);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
}
}
else {
/* n points in total */
for (i = 0; i < n; ++i) {
double x, y, z;
G_percent(i, n, 4);
Vect_reset_line(Points);
Vect_reset_cats(Cats);
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
if (nareas) {
int outside = 1;
do {
/* select areas by box */
box.E = x;
box.W = x;
box.N = y;
box.S = y;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&In, &box, List);
G_debug(3, " %d areas selected by box", List->n_values);
/* sort areas by size, the smallest is likely to be the nearest */
if (alloc_size_list < List->n_values) {
alloc_size_list = List->n_values;
size_list = G_realloc(size_list, alloc_size_list * sizeof(BOX_SIZE));
}
k = 0;
for (j = 0; j < List->n_values; j++) {
area = List->id[j];
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
List->id[k] = List->id[j];
List->box[k] = List->box[j];
size_list[k].i = List->id[k];
box = List->box[k];
size_list[k].box = List->box[k];
size_list[k].size = (box.N - box.S) * (box.E - box.W);
k++;
}
List->n_values = k;
if (List->n_values == 2) {
/* simple swap */
if (size_list[1].size < size_list[0].size) {
size_list[0].i = List->id[1];
size_list[1].i = List->id[0];
size_list[0].box = List->box[1];
size_list[1].box = List->box[0];
}
}
else if (List->n_values > 2)
qsort(size_list, List->n_values, sizeof(BOX_SIZE), sort_by_size);
for (j = 0; j < List->n_values; j++) {
int ret;
area = size_list[j].i;
ret = Vect_point_in_area(x, y, &In, area, &size_list[j].box);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
break;
}
}
if (outside) {
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
}
} while (outside);
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, i + 1);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
G_percent(1, 1, 1);
}
if (parm.zcol->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
if (!flag.notopo->answer) {
Vect_build(&Out);
}
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int ii;
int ret_val;
struct Cell_head cellhd;
struct WaterParams wp;
struct options parm;
struct flags flag;
long seed_value;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("soil"));
G_add_keyword(_("sediment flow"));
G_add_keyword(_("erosion"));
G_add_keyword(_("deposition"));
G_add_keyword(_("model"));
module->description =
_("Sediment transport and erosion/deposition simulation "
"using path sampling method (SIMWE).");
parm.elevin = G_define_standard_option(G_OPT_R_ELEV);
parm.wdepth = G_define_standard_option(G_OPT_R_INPUT);
parm.wdepth->key = "water_depth";
parm.wdepth->description = _("Name of water depth raster map [m]");
parm.dxin = G_define_standard_option(G_OPT_R_INPUT);
parm.dxin->key = "dx";
parm.dxin->description = _("Name of x-derivatives raster map [m/m]");
parm.dyin = G_define_standard_option(G_OPT_R_INPUT);
parm.dyin->key = "dy";
parm.dyin->description = _("Name of y-derivatives raster map [m/m]");
parm.detin = G_define_standard_option(G_OPT_R_INPUT);
parm.detin->key = "detachment_coeff";
parm.detin->description =
_("Name of detachment capacity coefficient raster map [s/m]");
parm.tranin = G_define_standard_option(G_OPT_R_INPUT);
parm.tranin->key = "transport_coeff";
parm.tranin->description =
_("Name of transport capacity coefficient raster map [s]");
parm.tauin = G_define_standard_option(G_OPT_R_INPUT);
parm.tauin->key = "shear_stress";
parm.tauin->description =
_("Name of critical shear stress raster map [Pa]");
parm.manin = G_define_standard_option(G_OPT_R_INPUT);
parm.manin->key = "man";
parm.manin->required = NO;
parm.manin->description = _("Name of Manning's n raster map");
parm.manin->guisection = _("Input");
parm.maninval = G_define_option();
parm.maninval->key = "man_value";
parm.maninval->type = TYPE_DOUBLE;
parm.maninval->answer = MANINVAL;
parm.maninval->required = NO;
parm.maninval->description = _("Manning's n unique value");
parm.maninval->guisection = _("Input");
parm.observation = G_define_standard_option(G_OPT_V_INPUT);
parm.observation->key = "observation";
parm.observation->required = NO;
parm.observation->label =
_("Name of sampling locations vector points map");
parm.observation->guisection = _("Input");
parm.tc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.tc->key = "transport_capacity";
parm.tc->required = NO;
parm.tc->description = _("Name for output transport capacity raster map [kg/ms]");
parm.tc->guisection = _("Output");
parm.et = G_define_standard_option(G_OPT_R_OUTPUT);
parm.et->key = "tlimit_erosion_deposition";
parm.et->required = NO;
parm.et->description =
_("Name for output transport limited erosion-deposition raster map [kg/m2s]");
parm.et->guisection = _("Output");
parm.conc = G_define_standard_option(G_OPT_R_OUTPUT);
parm.conc->key = "sediment_concentration";
parm.conc->required = NO;
parm.conc->description =
_("Name for output sediment concentration raster map [particle/m3]");
parm.conc->guisection = _("Output");
parm.flux = G_define_standard_option(G_OPT_R_OUTPUT);
parm.flux->key = "sediment_flux";
parm.flux->required = NO;
parm.flux->description = _("Name for output sediment flux raster map [kg/ms]");
parm.flux->guisection = _("Output");
parm.erdep = G_define_standard_option(G_OPT_R_OUTPUT);
parm.erdep->key = "erosion_deposition";
parm.erdep->required = NO;
parm.erdep->description =
_("Name for output erosion-deposition raster map [kg/m2s]");
parm.erdep->guisection = _("Output");
parm.logfile = G_define_standard_option(G_OPT_F_OUTPUT);
parm.logfile->key = "logfile";
parm.logfile->required = NO;
parm.logfile->description =
_("Name for sampling points output text file. For each observation vector point the time series of sediment transport is stored.");
parm.logfile->guisection = _("Output");
parm.outwalk = G_define_standard_option(G_OPT_V_OUTPUT);
parm.outwalk->key = "walkers_output";
parm.outwalk->required = NO;
parm.outwalk->description =
_("Base name of the output walkers vector points map");
parm.outwalk->guisection = _("Output");
parm.nwalk = G_define_option();
parm.nwalk->key = "nwalkers";
parm.nwalk->type = TYPE_INTEGER;
parm.nwalk->required = NO;
parm.nwalk->description = _("Number of walkers");
parm.nwalk->guisection = _("Parameters");
parm.niter = G_define_option();
parm.niter->key = "niterations";
parm.niter->type = TYPE_INTEGER;
parm.niter->answer = NITER;
parm.niter->required = NO;
parm.niter->description = _("Time used for iterations [minutes]");
parm.niter->guisection = _("Parameters");
parm.outiter = G_define_option();
parm.outiter->key = "output_step";
parm.outiter->type = TYPE_INTEGER;
parm.outiter->answer = ITEROUT;
parm.outiter->required = NO;
parm.outiter->description =
_("Time interval for creating output maps [minutes]");
parm.outiter->guisection = _("Parameters");
/*
parm.density = G_define_option();
parm.density->key = "density";
parm.density->type = TYPE_INTEGER;
parm.density->answer = DENSITY;
parm.density->required = NO;
parm.density->description = _("Density of output walkers");
parm.density->guisection = _("Parameters");
*/
parm.diffc = G_define_option();
parm.diffc->key = "diffusion_coeff";
parm.diffc->type = TYPE_DOUBLE;
parm.diffc->answer = DIFFC;
parm.diffc->required = NO;
parm.diffc->description = _("Water diffusion constant");
parm.diffc->guisection = _("Parameters");
parm.seed = G_define_option();
parm.seed->key = "random_seed";
parm.seed->type = TYPE_INTEGER;
parm.seed->required = NO;
parm.seed->label = _("Seed for random number generator");
parm.seed->description =
_("The same seed can be used to obtain same results"
" or random seed can be generated by other means.");
flag.generateSeed = G_define_flag();
flag.generateSeed->key = 's';
flag.generateSeed->label =
_("Generate random seed");
flag.generateSeed->description =
_("Automatically generates random seed for random number"
" generator (use when you don't want to provide the seed option)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (flag.generateSeed->answer) {
seed_value = G_srand48_auto();
G_verbose_message(_("Generated random seed (-s): %ld"), seed_value);
}
else if (parm.seed->answer) {
seed_value = atol(parm.seed->answer);
G_srand48(seed_value);
G_verbose_message(_("Read random seed from %s option: %ld"),
parm.seed->key, seed_value);
}
else {
/* default as it used to be */
G_srand48(12345);
}
G_get_set_window(&cellhd);
WaterParams_init(&wp);
wp.conv = G_database_units_to_meters_factor();
wp.mixx = cellhd.west * wp.conv;
wp.maxx = cellhd.east * wp.conv;
wp.miyy = cellhd.south * wp.conv;
wp.mayy = cellhd.north * wp.conv;
wp.stepx = cellhd.ew_res * wp.conv;
wp.stepy = cellhd.ns_res * wp.conv;
/* wp.step = amin1(wp.stepx,wp.stepy); */
wp.step = (wp.stepx + wp.stepy) / 2.;
wp.mx = cellhd.cols;
wp.my = cellhd.rows;
wp.xmin = 0.;
wp.ymin = 0.;
wp.xp0 = wp.xmin + wp.stepx / 2.;
wp.yp0 = wp.ymin + wp.stepy / 2.;
wp.xmax = wp.xmin + wp.stepx * (float)wp.mx;
wp.ymax = wp.ymin + wp.stepy * (float)wp.my;
wp.hhc = wp.hhmax = 0.;
#if 0
wp.bxmi = 2093113. * wp.conv;
wp.bymi = 731331. * wp.conv;
wp.bxma = 2093461. * wp.conv;
wp.byma = 731529. * wp.conv;
wp.bresx = 2. * wp.conv;
wp.bresy = 2. * wp.conv;
wp.maxwab = 100000;
wp.mx2o = (int)((wp.bxma - wp.bxmi) / wp.bresx);
wp.my2o = (int)((wp.byma - wp.bymi) / wp.bresy);
/* relative small box coordinates: leave 1 grid layer for overlap */
wp.bxmi = wp.bxmi - wp.mixx + wp.stepx;
wp.bymi = wp.bymi - wp.miyy + wp.stepy;
wp.bxma = wp.bxma - wp.mixx - wp.stepx;
wp.byma = wp.byma - wp.miyy - wp.stepy;
wp.mx2 = wp.mx2o - 2 * ((int)(wp.stepx / wp.bresx));
wp.my2 = wp.my2o - 2 * ((int)(wp.stepy / wp.bresy));
#endif
wp.elevin = parm.elevin->answer;
wp.wdepth = parm.wdepth->answer;
wp.dxin = parm.dxin->answer;
wp.dyin = parm.dyin->answer;
wp.detin = parm.detin->answer;
wp.tranin = parm.tranin->answer;
wp.tauin = parm.tauin->answer;
wp.manin = parm.manin->answer;
wp.tc = parm.tc->answer;
wp.et = parm.et->answer;
wp.conc = parm.conc->answer;
wp.flux = parm.flux->answer;
wp.erdep = parm.erdep->answer;
wp.outwalk = parm.outwalk->answer;
/* sscanf(parm.nwalk->answer, "%d", &wp.maxwa); */
sscanf(parm.niter->answer, "%d", &wp.timesec);
sscanf(parm.outiter->answer, "%d", &wp.iterout);
/* sscanf(parm.density->answer, "%d", &wp.ldemo); */
sscanf(parm.diffc->answer, "%lf", &wp.frac);
sscanf(parm.maninval->answer, "%lf", &wp.manin_val);
/* Recompute timesec from user input in minutes
* to real timesec in seconds */
wp.timesec = wp.timesec * 60;
wp.iterout = wp.iterout * 60;
if ((wp.timesec / wp.iterout) > 100)
G_message(_("More than 100 files are going to be created !!!!!"));
/* compute how big the raster is and set this to appr 2 walkers per cell */
if (parm.nwalk->answer == NULL) {
wp.maxwa = wp.mx * wp.my * 2;
wp.rwalk = (double)(wp.mx * wp.my * 2.);
G_message(_("default nwalk=%d, rwalk=%f"), wp.maxwa, wp.rwalk);
}
else {
sscanf(parm.nwalk->answer, "%d", &wp.maxwa);
wp.rwalk = (double)wp.maxwa;
}
/*rwalk = (double) maxwa; */
if (wp.conv != 1.0)
G_message(_("Using metric conversion factor %f, step=%f"), wp.conv,
wp.step);
init_library_globals(&wp);
if ((wp.tc == NULL) && (wp.et == NULL) && (wp.conc == NULL) && (wp.flux == NULL) &&
(wp.erdep == NULL))
G_warning(_("You are not outputting any raster or site files"));
ret_val = input_data();
if (ret_val != 1)
G_fatal_error(_("Input failed"));
alloc_grids_sediment();
grad_check();
init_grids_sediment();
/* treba dat output pre topoerdep */
main_loop();
/* always true for sediment? */
if (wp.tserie == NULL) {
ii = output_data(0, 1.);
if (ii != 1)
G_fatal_error(_("Cannot write raster maps"));
}
/* Exit with Success */
exit(EXIT_SUCCESS);
}
struct cache *readcell(int fdi, int size, int target_env)
{
DCELL *tmpbuf;
struct cache *c;
int nrows;
int ncols;
int row;
char *filename;
int nx, ny;
int nblocks;
int i;
if (target_env)
select_target_env();
else
select_current_env();
G_srand48(0);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Temporary file must be created in the same location/mapset
* where the module was called */
if (target_env)
select_current_env();
ny = (nrows + BDIM - 1) / BDIM;
nx = (ncols + BDIM - 1) / BDIM;
if (size > 0)
nblocks = size * ((1 << 20) / sizeof(block));
else
nblocks = (nx + ny) * 2; /* guess */
if (nblocks > nx * ny)
nblocks = nx * ny;
c = G_malloc(sizeof(struct cache));
c->stride = nx;
c->nblocks = nblocks;
c->grid = (block **) G_calloc(nx * ny, sizeof(block *));
c->blocks = (block *) G_malloc(nblocks * sizeof(block));
c->refs = (int *)G_malloc(nblocks * sizeof(int));
if (nblocks < nx * ny) {
filename = G_tempfile();
c->fd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
if (c->fd < 0)
G_fatal_error(_("Unable to open temporary file"));
remove(filename);
}
else
c->fd = -1;
G_debug(1, "%d of %d blocks in memory", nblocks, nx * ny);
G_important_message(_("Allocating memory and reading input map..."));
G_percent(0, nrows, 5);
for (i = 0; i < c->nblocks; i++)
c->refs[i] = -1;
tmpbuf = (DCELL *) G_malloc(nx * sizeof(block));
if (target_env)
select_target_env();
for (row = 0; row < nrows; row += BDIM) {
int x, y;
for (y = 0; y < BDIM; y++) {
G_percent(row + y, nrows, 5);
if (row + y >= nrows)
break;
Rast_get_d_row(fdi, &tmpbuf[y * nx * BDIM], row + y);
}
for (x = 0; x < nx; x++)
for (y = 0; y < BDIM; y++)
if (c->fd >= 0) {
if (write
(c->fd, &tmpbuf[(y * nx + x) * BDIM],
BDIM * sizeof(DCELL)) < 0)
G_fatal_error(_("Error writing segment file"));
}
else
memcpy(&c->blocks[BKIDX(c, HI(row), x)][LO(y)][0],
&tmpbuf[(y * nx + x) * BDIM],
BDIM * sizeof(DCELL));
}
G_free(tmpbuf);
if (c->fd < 0)
for (i = 0; i < c->nblocks; i++) {
c->grid[i] = &c->blocks[i];
c->refs[i] = i;
}
if (target_env)
select_current_env();
return c;
}