/*
** main program:
** initialise, timestep loop, finalise
*/
int main(int argc, char* argv[])
{
char * final_state_file = NULL;
char * av_vels_file = NULL;
char * param_file = NULL;
accel_area_t accel_area;
param_t params; /* struct to hold parameter values */
speed_t* cells = NULL; /* grid containing fluid densities */
speed_t* tmp_cells = NULL; /* scratch space */
int* obstacles = NULL; /* grid indicating which cells are blocked */
double* av_vels = NULL; /* a record of the av. velocity computed for each timestep */
int ii; /* generic counter */
struct timeval timstr; /* structure to hold elapsed time */
struct rusage ru; /* structure to hold CPU time--system and user */
double tic,toc; /* floating point numbers to calculate elapsed wallclock time */
double usrtim; /* floating point number to record elapsed user CPU time */
double systim; /* floating point number to record elapsed system CPU time */
parse_args(argc, argv, &final_state_file, &av_vels_file, ¶m_file);
initialise(param_file, &accel_area, ¶ms, &cells, &tmp_cells, &obstacles, &av_vels);
/* iterate for max_iters timesteps */
gettimeofday(&timstr,NULL);
tic=timstr.tv_sec+(timstr.tv_usec/1000000.0);
for (ii = 0; ii < params.max_iters; ii++)
{
timestep(params, accel_area, cells, tmp_cells, obstacles);
av_vels[ii] = av_velocity(params, cells, obstacles);
#ifdef DEBUG
printf("==timestep: %d==\n", ii);
printf("av velocity: %.12E\n", av_vels[ii]);
printf("tot density: %.12E\n", total_density(params, cells));
#endif
}
gettimeofday(&timstr,NULL);
toc=timstr.tv_sec+(timstr.tv_usec/1000000.0);
getrusage(RUSAGE_SELF, &ru);
timstr=ru.ru_utime;
usrtim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
timstr=ru.ru_stime;
systim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
printf("==done==\n");
printf("Reynolds number:\t\t%.12E\n", calc_reynolds(params,cells,obstacles));
printf("Elapsed time:\t\t\t%.6f (s)\n", toc-tic);
printf("Elapsed user CPU time:\t\t%.6f (s)\n", usrtim);
printf("Elapsed system CPU time:\t%.6f (s)\n", systim);
write_values(final_state_file, av_vels_file, params, cells, obstacles, av_vels);
finalise(&cells, &tmp_cells, &obstacles, &av_vels);
return EXIT_SUCCESS;
}
/*
** main program:
** initialise, timestep loop, finalise
*/
int main(int argc, char* argv[])
{
char* paramfile; /* name of the input parameter file */
char* obstaclefile; /* name of a the input obstacle file */
t_param params; /* struct to hold parameter values */
t_speed* cells = NULL; /* grid containing fluid densities */
t_speed* tmp_cells = NULL; /* scratch space */
int* obstacles = NULL; /* grid indicating which cells are blocked */
float* av_vels = NULL; /* a record of the av. velocity computed for each timestep */
int ii; /* generic counter */
struct timeval timstr; /* structure to hold elapsed time */
struct rusage ru; /* structure to hold CPU time--system and user */
double tic,toc; /* floating point numbers to calculate elapsed wallclock time */
double usrtim; /* floating point number to record elapsed user CPU time */
double systim; /* floating point number to record elapsed system CPU time */
/* parse the command line */
if(argc != 3) {
usage(argv[0]);
}
else{
paramfile = argv[1];
obstaclefile = argv[2];
}
/* initialise our data structures and load values from file */
initialise(paramfile, obstaclefile, ¶ms, &cells, &tmp_cells, &obstacles, &av_vels);
/* iterate for maxIters timesteps */
gettimeofday(&timstr,NULL);
tic=timstr.tv_sec+(timstr.tv_usec/1000000.0);
for (ii=0;ii<params.maxIters;ii++) {
timestep(params,cells,tmp_cells,obstacles);
av_vels[ii] = av_velocity(params,cells,obstacles);
#ifdef DEBUG
printf("==timestep: %d==\n",ii);
printf("av velocity: %.12E\n", av_vels[ii]);
printf("tot density: %.12E\n",total_density(params,cells));
#endif
}
gettimeofday(&timstr,NULL);
toc=timstr.tv_sec+(timstr.tv_usec/1000000.0);
getrusage(RUSAGE_SELF, &ru);
timstr=ru.ru_utime;
usrtim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
timstr=ru.ru_stime;
systim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
/* write final values and free memory */
printf("==done==\n");
printf("Reynolds number:\t\t%.12E\n",calc_reynolds(params,cells,obstacles));
printf("Elapsed time:\t\t\t%.6lf (s)\n", toc-tic);
printf("Elapsed user CPU time:\t\t%.6lf (s)\n", usrtim);
printf("Elapsed system CPU time:\t%.6lf (s)\n", systim);
write_values(params,cells,obstacles,av_vels);
finalise(¶ms, &cells, &tmp_cells, &obstacles, &av_vels);
return EXIT_SUCCESS;
}
preferencesDialog::preferencesDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::preferencesDialog)
{
ui->setupUi(this);
populateLocale();
initSettings();
connect(this,SIGNAL(accepted()),this,SLOT(write_values()));
}
int main(int argc, char **argv) {
int fd = -1;
int retval = EXIT_SUCCESS;
if(argc < 2) {
fprintf(stderr,
"%s version %s-%s\n"
"\nUsage:\n"
"\tread addr: address\n"
"\twrite addr: address value\n"
"\tset slow DAC: -sdac AO0 AO1 AO2 AO3 [V]\n",
argv[0], VERSION_STR, REVISION_STR);
return EXIT_FAILURE;
}
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
/* Read from command line */
unsigned long addr;
unsigned long *val = NULL;
int access_type = 'w';
ssize_t val_count = 0;
parse_from_argv(argc, argv, &addr, &access_type, &val, &val_count);
/* Map one page */
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
if (addr != 0) {
if (val_count == 0) {
read_value(addr);
}
else {
write_values(addr, access_type, val, val_count);
}
}
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
map_base = (void*)(-1);
}
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
}
if (fd != -1) {
close(fd);
}
return retval;
}
int main(int argc, char **argv) {
int fd = -1;
int retval = EXIT_SUCCESS;
if(argc < 2) {
fprintf(stderr,
"%s version %s-%s\n"
"\nUsage:\n"
"\tread addr: address\n"
"\twrite addr: address value\n"
"\tread analog mixed signals: -ams\n"
"\tset slow DAC: -sdac AO0 AO1 AO2 AO3 [V]\n",
argv[0], VERSION_STR, REVISION_STR);
return EXIT_FAILURE;
}
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
/* Read from standard input */
if (strncmp(argv[1], "-ams", 4) == 0) {
uint32_t addr = c_addrAms;
amsReg_t* ams=NULL;
// Map one page
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
ams = map_base + (addr & MAP_MASK);
AmsList(ams);
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
map_base = (void*)(-1);
}
}
else if (strncmp(argv[1], "-sdac", 5) == 0) {
uint32_t addr = c_addrAms;
amsReg_t* ams=NULL;
double *val = NULL;
ssize_t val_count = 0;
parse_from_argv_par(argc, argv, &val, &val_count);
if(val_count>SLOW_DAC_NUM){
val_count=SLOW_DAC_NUM;
}
// Map one page
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
ams = map_base + (addr & MAP_MASK);
if (val_count == 0) {
DacRead(ams);
}
else{
DacWrite(ams, val, val_count);
}
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
map_base = (void*)(-1);
}
}
else if (strncmp(argv[1], "-", 1) == 0) {
unsigned long addr;
unsigned long *val = NULL;
int access_type = 'w';
ssize_t val_count = 0;
while ( parse_from_stdin(&addr, &access_type, &val, &val_count) != -1) {
if (addr == 0) {
continue;
}
/* Map one page */
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
if (val_count == 0) {
read_value(addr);
}
else {
write_values(addr, access_type, val, val_count);
}
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
map_base = (void*)(-1);
}
#if DEBUG_MONITOR
printf("addr/type: %lu/%c\n", addr, access_type);
printf("val (%ld):", val_count);
for (ssize_t i = 0; i < val_count; ++i) {
printf("%lu ", val[i]);
}
if (val != NULL) {
free(val);
val = NULL;
}
printf("\n");
#endif
}
goto exit;
}
/* Read from command line */
else {
unsigned long addr;
unsigned long *val = NULL;
int access_type = 'w';
ssize_t val_count = 0;
parse_from_argv(argc, argv, &addr, &access_type, &val, &val_count);
/* Map one page */
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, addr & ~MAP_MASK);
if(map_base == (void *) -1) FATAL;
if (addr != 0) {
if (val_count == 0) {
read_value(addr);
}
else {
write_values(addr, access_type, val, val_count);
}
}
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
map_base = (void*)(-1);
}
#if DEBUG_MONITOR
printf("addr/type: %lu/%c\n", addr, access_type);
printf("val (%ld):", val_count);
for (ssize_t i = 0; i < val_count; ++i) {
printf("%lu ", val[i]);
}
if (val != NULL) {
free(val);
val = NULL;
}
printf("\n");
#endif
}
exit:
if (map_base != (void*)(-1)) {
if(munmap(map_base, MAP_SIZE) == -1) FATAL;
}
if (fd != -1) {
close(fd);
}
return retval;
}
int main(int argc, char* argv[])
{
char* paramfile; /* name of the input parameter file */
char* obstaclefile; /* name of a the input obstacle file */
t_param params; /* struct to hold parameter values */
t_speed* cells = NULL; /* grid containing fluid densities */
t_speed* tmp_cells = NULL; /* scratch space */
int* obstacles = NULL; /* grid indicating which cells are blocked */
float* av_vels = NULL; /* a record of the av. velocity computed for each timestep */
int ii; /* generic counter */
struct timeval timstr; /* structure to hold elapsed time */
struct rusage ru; /* structure to hold CPU time--system and user */
double tic,toc; /* floating point numbers to calculate elapsed wallclock time */
double usrtim; /* floating point number to record elapsed user CPU time */
double systim; /* floating point number to record elapsed system CPU time */
/* parse the command line */
if(argc != 3) {
usage(argv[0]);
}
else{
paramfile = argv[1];
obstaclefile = argv[2];
}
/* initialise our data structures and load values from file */
initialise(paramfile, obstaclefile, ¶ms, &cells, &tmp_cells, &obstacles, &av_vels);
/* iterate for maxIters timesteps */
gettimeofday(&timstr,NULL);
tic=timstr.tv_sec+(timstr.tv_usec/1000000.0);
float tot_u_x=0;
int tot_cells = 0;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
int start=0, end=0, ff, hh, gg;
params.rest = params.ny%nprocs;
for (ii=0;ii<params.maxIters;ii++) {
timestep(params,cells,tmp_cells,obstacles);
if(ii==1){
atyt = 0;
}
if(ii==2){
atyt = 1;
}
///////////av_velocity.................................................
int jj,kk, tt, source;
float local_density;
float l_tot_u_x=0;
int l_tot_cells = 0;
if(params.rest!=0){
if(rank>=params.rest){
start = params.rest*(params.ny/nprocs+1) + (rank-params.rest)*(params.ny/nprocs);
end= start+params.ny/nprocs-1;
}
else{
start = rank*(params.ny/nprocs+1);
end = start+params.ny/nprocs;
}
}
for(kk=start;kk<=end;kk++)
{
for(jj=0;jj<params.nx;jj++)
{
if(!obstacles[kk*params.nx + jj])
{
local_density= 0.0;
for(tt=0;tt<NSPEEDS;tt++)
{
local_density += cells[kk*params.nx + jj].speeds[tt];
}
l_tot_u_x += (cells[kk*params.nx + jj].speeds[1] +
cells[kk*params.nx + jj].speeds[5] +
cells[kk*params.nx + jj].speeds[8]
- (cells[kk*params.nx + jj].speeds[3] +
cells[kk*params.nx + jj].speeds[6] +
cells[kk*params.nx + jj].speeds[7])) /
local_density;
l_tot_cells+=1;
}
}
}
if(rank!=MASTER){
MPI_Send(&l_tot_u_x, 1, MPI_FLOAT, dest, tag, MPI_COMM_WORLD);
MPI_Send(&l_tot_cells, 1, MPI_INT, dest, tag, MPI_COMM_WORLD);}
else{
tot_cells = l_tot_cells;
for (source =1; source < nprocs; source++) {
MPI_Recv(&l_tot_u_x, 1, MPI_FLOAT, source, tag, MPI_COMM_WORLD, &status);
tot_u_x+=l_tot_u_x;
MPI_Recv(&l_tot_cells, 1, MPI_INT, source, tag, MPI_COMM_WORLD, &status);
tot_cells+=l_tot_cells;
}
av_vels[ii] = tot_u_x / (float)tot_cells;
}
}
float mes[9*params.nx];
float mes2[9*params.nx];
if(rank!=MASTER){
if(params.rest!=0){
if(rank>=params.rest){
start = params.rest*(params.ny/nprocs+1) + (rank-params.rest)*(params.ny/nprocs);
end= start+params.ny/nprocs-1;
}
else{
start = rank*(params.ny/nprocs+1);
end = start+params.ny/nprocs;
}
}
for(gg=start;gg<=end;gg++) {
for(hh=0;hh<params.nx;hh++){
for(ff=0;ff<9;ff++){
mes[9*hh+ff] = cells[gg*params.nx + hh].speeds[ff];
}
}
}
MPI_Isend(mes, 9*params.nx, MPI_FLOAT, MASTER, tag, MPI_COMM_WORLD, &request);
}
if(rank == MASTER){
for(source=1;source<nprocs;source++){
if(params.rest!=0){
if(source>=params.rest){
start = params.rest*(params.ny/nprocs+1) + (source-params.rest)*(params.ny/nprocs);
end= start+params.ny/nprocs-1;
}
else{
start = source*(params.ny/nprocs+1);
end = start+params.ny/nprocs;
}
}
for(gg=start;gg<=end;gg++) {
MPI_Irecv(mes2, 9*params.nx, MPI_FLOAT, source, tag, MPI_COMM_WORLD, &request);
for(hh=0;hh<params.nx;hh++){
for(ff=0;ff<9;ff++){
cells[gg*params.nx + hh].speeds[ff]=mes2[9*hh+ff];
}
}
}
}
}
///////////av_velocity.................................................
MPI_Finalize();
gettimeofday(&timstr,NULL);
toc=timstr.tv_sec+(timstr.tv_usec/1000000.0);
getrusage(RUSAGE_SELF, &ru);
timstr=ru.ru_utime;
usrtim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
timstr=ru.ru_stime;
systim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
if(rank==0){
/* write final values and free memory */
printf("==done==\n");
printf("Reynolds number:\t\t%.12E\n",calc_reynolds(params,cells,obstacles));
printf("Elapsed time:\t\t\t%.6lf (s)\n", toc-tic);
printf("Elapsed user CPU time:\t\t%.6lf (s)\n", usrtim);
printf("Elapsed system CPU time:\t%.6lf (s)\n", systim);
write_values(params,cells,obstacles,av_vels);
finalise(¶ms, &cells, &tmp_cells, &obstacles, &av_vels);
//openFile(); // OPEN THE MULTIPLE OUTPUT FILE
//printf("\n\n%f\n", toc-tic);
//printF(toc-tic);
// fclose(ofp);
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int out_fd, base_raster;
char *infile, *outmap;
int percent;
double zrange_min, zrange_max, d_tmp;
double irange_min, irange_max;
unsigned long estimated_lines;
RASTER_MAP_TYPE rtype, base_raster_data_type;
struct History history;
char title[64];
SEGMENT base_segment;
struct PointBinning point_binning;
void *base_array;
void *raster_row;
struct Cell_head region;
struct Cell_head input_region;
int rows, last_rows, row0, cols; /* scan box size */
int row; /* counters */
int pass, npasses;
unsigned long line, line_total;
unsigned int counter;
unsigned long n_invalid;
char buff[BUFFSIZE];
double x, y, z;
double intensity;
int arr_row, arr_col;
unsigned long count, count_total;
int point_class;
double zscale = 1.0;
double iscale = 1.0;
double res = 0.0;
struct BinIndex bin_index_nodes;
bin_index_nodes.num_nodes = 0;
bin_index_nodes.max_nodes = 0;
bin_index_nodes.nodes = 0;
struct GModule *module;
struct Option *input_opt, *output_opt, *percent_opt, *type_opt, *filter_opt, *class_opt;
struct Option *method_opt, *base_raster_opt;
struct Option *zrange_opt, *zscale_opt;
struct Option *irange_opt, *iscale_opt;
struct Option *trim_opt, *pth_opt, *res_opt;
struct Option *file_list_opt;
struct Flag *print_flag, *scan_flag, *shell_style, *over_flag, *extents_flag;
struct Flag *intens_flag, *intens_import_flag;
struct Flag *set_region_flag;
struct Flag *base_rast_res_flag;
struct Flag *only_valid_flag;
/* LAS */
LASReaderH LAS_reader;
LASHeaderH LAS_header;
LASSRSH LAS_srs;
LASPointH LAS_point;
int return_filter;
const char *projstr;
struct Cell_head cellhd, loc_wind;
unsigned int n_filtered;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("LIDAR"));
G_add_keyword(_("statistics"));
G_add_keyword(_("conversion"));
G_add_keyword(_("aggregation"));
G_add_keyword(_("binning"));
module->description =
_("Creates a raster map from LAS LiDAR points using univariate statistics.");
input_opt = G_define_standard_option(G_OPT_F_BIN_INPUT);
input_opt->required = NO;
input_opt->label = _("LAS input file");
input_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)");
input_opt->guisection = _("Input");
output_opt = G_define_standard_option(G_OPT_R_OUTPUT);
output_opt->required = NO;
output_opt->guisection = _("Output");
file_list_opt = G_define_standard_option(G_OPT_F_INPUT);
file_list_opt->key = "file";
file_list_opt->label = _("File containing names of LAS input files");
file_list_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)");
file_list_opt->required = NO;
file_list_opt->guisection = _("Input");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->description = _("Statistic to use for raster values");
method_opt->options =
"n,min,max,range,sum,mean,stddev,variance,coeff_var,median,percentile,skewness,trimmean";
method_opt->answer = "mean";
method_opt->guisection = _("Statistic");
G_asprintf((char **)&(method_opt->descriptions),
"n;%s;"
"min;%s;"
"max;%s;"
"range;%s;"
"sum;%s;"
"mean;%s;"
"stddev;%s;"
"variance;%s;"
"coeff_var;%s;"
"median;%s;"
"percentile;%s;"
"skewness;%s;"
"trimmean;%s",
_("Number of points in cell"),
_("Minimum value of point values in cell"),
_("Maximum value of point values in cell"),
_("Range of point values in cell"),
_("Sum of point values in cell"),
_("Mean (average) value of point values in cell"),
_("Standard deviation of point values in cell"),
_("Variance of point values in cell"),
_("Coefficient of variance of point values in cell"),
_("Median value of point values in cell"),
_("pth (nth) percentile of point values in cell"),
_("Skewness of point values in cell"),
_("Trimmed mean of point values in cell"));
type_opt = G_define_standard_option(G_OPT_R_TYPE);
type_opt->required = NO;
type_opt->answer = "FCELL";
base_raster_opt = G_define_standard_option(G_OPT_R_INPUT);
base_raster_opt->key = "base_raster";
base_raster_opt->required = NO;
base_raster_opt->label =
_("Subtract raster values from the Z coordinates");
base_raster_opt->description =
_("The scale for Z is applied beforehand, the range filter for"
" Z afterwards");
base_raster_opt->guisection = _("Transform");
zrange_opt = G_define_option();
zrange_opt->key = "zrange";
zrange_opt->type = TYPE_DOUBLE;
zrange_opt->required = NO;
zrange_opt->key_desc = "min,max";
zrange_opt->description = _("Filter range for Z data (min,max)");
zrange_opt->guisection = _("Selection");
zscale_opt = G_define_option();
zscale_opt->key = "zscale";
zscale_opt->type = TYPE_DOUBLE;
zscale_opt->required = NO;
zscale_opt->answer = "1.0";
zscale_opt->description = _("Scale to apply to Z data");
zscale_opt->guisection = _("Transform");
irange_opt = G_define_option();
irange_opt->key = "intensity_range";
irange_opt->type = TYPE_DOUBLE;
irange_opt->required = NO;
irange_opt->key_desc = "min,max";
irange_opt->description = _("Filter range for intensity values (min,max)");
irange_opt->guisection = _("Selection");
iscale_opt = G_define_option();
iscale_opt->key = "intensity_scale";
iscale_opt->type = TYPE_DOUBLE;
iscale_opt->required = NO;
iscale_opt->answer = "1.0";
iscale_opt->description = _("Scale to apply to intensity values");
iscale_opt->guisection = _("Transform");
percent_opt = G_define_option();
percent_opt->key = "percent";
percent_opt->type = TYPE_INTEGER;
percent_opt->required = NO;
percent_opt->answer = "100";
percent_opt->options = "1-100";
percent_opt->description = _("Percent of map to keep in memory");
/* I would prefer to call the following "percentile", but that has too
* much namespace overlap with the "percent" option above */
pth_opt = G_define_option();
pth_opt->key = "pth";
pth_opt->type = TYPE_INTEGER;
pth_opt->required = NO;
pth_opt->options = "1-100";
pth_opt->description = _("pth percentile of the values");
pth_opt->guisection = _("Statistic");
trim_opt = G_define_option();
trim_opt->key = "trim";
trim_opt->type = TYPE_DOUBLE;
trim_opt->required = NO;
trim_opt->options = "0-50";
trim_opt->label = _("Discard given percentage of the smallest and largest values");
trim_opt->description =
_("Discard <trim> percent of the smallest and <trim> percent of the largest observations");
trim_opt->guisection = _("Statistic");
res_opt = G_define_option();
res_opt->key = "resolution";
res_opt->type = TYPE_DOUBLE;
res_opt->required = NO;
res_opt->description =
_("Output raster resolution");
res_opt->guisection = _("Output");
filter_opt = G_define_option();
filter_opt->key = "return_filter";
filter_opt->type = TYPE_STRING;
filter_opt->required = NO;
filter_opt->label = _("Only import points of selected return type");
filter_opt->description = _("If not specified, all points are imported");
filter_opt->options = "first,last,mid";
filter_opt->guisection = _("Selection");
class_opt = G_define_option();
class_opt->key = "class_filter";
class_opt->type = TYPE_INTEGER;
class_opt->multiple = YES;
class_opt->required = NO;
class_opt->label = _("Only import points of selected class(es)");
class_opt->description = _("Input is comma separated integers. "
"If not specified, all points are imported.");
class_opt->guisection = _("Selection");
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->description =
_("Print LAS file info and exit");
extents_flag = G_define_flag();
extents_flag->key = 'e';
extents_flag->label =
_("Use the extent of the input for the raster extent");
extents_flag->description =
_("Set internally computational region extents based on the"
" point cloud");
extents_flag->guisection = _("Output");
set_region_flag = G_define_flag();
set_region_flag->key = 'n';
set_region_flag->label =
_("Set computation region to match the new raster map");
set_region_flag->description =
_("Set computation region to match the 2D extent and resolution"
" of the newly created new raster map");
set_region_flag->guisection = _("Output");
over_flag = G_define_flag();
over_flag->key = 'o';
over_flag->label =
_("Override projection check (use current location's projection)");
over_flag->description =
_("Assume that the dataset has same projection as the current location");
scan_flag = G_define_flag();
scan_flag->key = 's';
scan_flag->description = _("Scan data file for extent then exit");
shell_style = G_define_flag();
shell_style->key = 'g';
shell_style->description =
_("In scan mode, print using shell script style");
intens_flag = G_define_flag();
intens_flag->key = 'i';
intens_flag->label =
_("Use intensity values rather than Z values");
intens_flag->description =
_("Uses intensity values everywhere as if they would be Z"
" coordinates");
intens_import_flag = G_define_flag();
intens_import_flag->key = 'j';
intens_import_flag->description =
_("Use Z values for filtering, but intensity values for statistics");
base_rast_res_flag = G_define_flag();
base_rast_res_flag->key = 'd';
base_rast_res_flag->label =
_("Use base raster resolution instead of computational region");
base_rast_res_flag->description =
_("For getting values from base raster, use its actual"
" resolution instead of computational region resolution");
only_valid_flag = G_define_flag();
only_valid_flag->key = 'v';
only_valid_flag->label = _("Use only valid points");
only_valid_flag->description =
_("Points invalid according to APSRS LAS specification will be"
" filtered out");
only_valid_flag->guisection = _("Selection");
G_option_required(input_opt, file_list_opt, NULL);
G_option_exclusive(input_opt, file_list_opt, NULL);
G_option_required(output_opt, print_flag, scan_flag, shell_style, NULL);
G_option_exclusive(intens_flag, intens_import_flag, NULL);
G_option_requires(base_rast_res_flag, base_raster_opt, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
int only_valid = FALSE;
n_invalid = 0;
if (only_valid_flag->answer)
only_valid = TRUE;
/* we could use rules but this gives more info and allows continuing */
if (set_region_flag->answer && !(extents_flag->answer || res_opt->answer)) {
G_warning(_("Flag %c makes sense only with %s option or -%c flag"),
set_region_flag->key, res_opt->key, extents_flag->key);
/* avoid the call later on */
set_region_flag->answer = '\0';
}
struct StringList infiles;
if (file_list_opt->answer) {
if (access(file_list_opt->answer, F_OK) != 0)
G_fatal_error(_("File <%s> does not exist"), file_list_opt->answer);
string_list_from_file(&infiles, file_list_opt->answer);
}
else {
string_list_from_one_item(&infiles, input_opt->answer);
}
/* parse input values */
outmap = output_opt->answer;
if (shell_style->answer && !scan_flag->answer) {
scan_flag->answer = 1; /* pointer not int, so set = shell_style->answer ? */
}
/* check zrange and extent relation */
if (scan_flag->answer || extents_flag->answer) {
if (zrange_opt->answer)
G_warning(_("zrange will not be taken into account during scan"));
}
Rast_get_window(®ion);
/* G_get_window seems to be unreliable if the location has been changed */
G_get_set_window(&loc_wind); /* TODO: v.in.lidar uses G_get_default_window() */
estimated_lines = 0;
int i;
for (i = 0; i < infiles.num_items; i++) {
infile = infiles.items[i];
/* don't if file not found */
if (access(infile, F_OK) != 0)
G_fatal_error(_("Input file <%s> does not exist"), infile);
/* Open LAS file*/
LAS_reader = LASReader_Create(infile);
if (LAS_reader == NULL)
G_fatal_error(_("Unable to open file <%s> as a LiDAR point cloud"),
infile);
LAS_header = LASReader_GetHeader(LAS_reader);
if (LAS_header == NULL) {
G_fatal_error(_("Unable to read LAS header of <%s>"), infile);
}
LAS_srs = LASHeader_GetSRS(LAS_header);
/* print info or check projection if we are actually importing */
if (print_flag->answer) {
/* print filename when there is more than one file */
if (infiles.num_items > 1)
fprintf(stdout, "File: %s\n", infile);
/* Print LAS header */
print_lasinfo(LAS_header, LAS_srs);
}
else {
/* report that we are checking more files */
if (i == 1)
G_message(_("First file's projection checked,"
" checking projection of the other files..."));
/* Fetch input map projection in GRASS form. */
projstr = LASSRS_GetWKT_CompoundOK(LAS_srs);
/* we are printing the non-warning messages only for first file */
projection_check_wkt(cellhd, loc_wind, projstr, over_flag->answer,
shell_style->answer || i);
/* if there is a problem in some other file, first OK message
* is printed but than a warning, this is not ideal but hopefully
* not so confusing when importing multiple files */
}
if (scan_flag->answer || extents_flag->answer) {
/* we assign to the first one (i==0) but update for the rest */
scan_bounds(LAS_reader, shell_style->answer, extents_flag->answer, i,
zscale, ®ion);
}
/* number of estimated point across all files */
/* TODO: this should be ull which won't work with percent report */
estimated_lines += LASHeader_GetPointRecordsCount(LAS_header);
/* We are closing all again and we will be opening them later,
* so we don't have to worry about limit for open files. */
LASSRS_Destroy(LAS_srs);
LASHeader_Destroy(LAS_header);
LASReader_Destroy(LAS_reader);
}
/* if we are not importing, end */
if (print_flag->answer || scan_flag->answer)
exit(EXIT_SUCCESS);
return_filter = LAS_ALL;
if (filter_opt->answer) {
if (strcmp(filter_opt->answer, "first") == 0)
return_filter = LAS_FIRST;
else if (strcmp(filter_opt->answer, "last") == 0)
return_filter = LAS_LAST;
else if (strcmp(filter_opt->answer, "mid") == 0)
return_filter = LAS_MID;
else
G_fatal_error(_("Unknown filter option <%s>"), filter_opt->answer);
}
struct ReturnFilter return_filter_struct;
return_filter_struct.filter = return_filter;
struct ClassFilter class_filter;
class_filter_create_from_strings(&class_filter, class_opt->answers);
percent = atoi(percent_opt->answer);
/* TODO: we already used zscale */
/* TODO: we don't report intensity range */
if (zscale_opt->answer)
zscale = atof(zscale_opt->answer);
if (iscale_opt->answer)
iscale = atof(iscale_opt->answer);
/* parse zrange */
if (zrange_opt->answer != NULL) {
if (zrange_opt->answers[0] == NULL)
G_fatal_error(_("Invalid zrange"));
sscanf(zrange_opt->answers[0], "%lf", &zrange_min);
sscanf(zrange_opt->answers[1], "%lf", &zrange_max);
if (zrange_min > zrange_max) {
d_tmp = zrange_max;
zrange_max = zrange_min;
zrange_min = d_tmp;
}
}
/* parse irange */
if (irange_opt->answer != NULL) {
if (irange_opt->answers[0] == NULL)
G_fatal_error(_("Invalid %s"), irange_opt->key);
sscanf(irange_opt->answers[0], "%lf", &irange_min);
sscanf(irange_opt->answers[1], "%lf", &irange_max);
if (irange_min > irange_max) {
d_tmp = irange_max;
irange_max = irange_min;
irange_min = d_tmp;
}
}
point_binning_set(&point_binning, method_opt->answer, pth_opt->answer,
trim_opt->answer, FALSE);
base_array = NULL;
if (strcmp("CELL", type_opt->answer) == 0)
rtype = CELL_TYPE;
else if (strcmp("DCELL", type_opt->answer) == 0)
rtype = DCELL_TYPE;
else
rtype = FCELL_TYPE;
if (point_binning.method == METHOD_N)
rtype = CELL_TYPE;
if (res_opt->answer) {
/* align to resolution */
res = atof(res_opt->answer);
if (!G_scan_resolution(res_opt->answer, &res, region.proj))
G_fatal_error(_("Invalid input <%s=%s>"), res_opt->key, res_opt->answer);
if (res <= 0)
G_fatal_error(_("Option '%s' must be > 0.0"), res_opt->key);
region.ns_res = region.ew_res = res;
region.north = ceil(region.north / res) * res;
region.south = floor(region.south / res) * res;
region.east = ceil(region.east / res) * res;
region.west = floor(region.west / res) * res;
G_adjust_Cell_head(®ion, 0, 0);
}
else if (extents_flag->answer) {
/* align to current region */
Rast_align_window(®ion, &loc_wind);
}
Rast_set_output_window(®ion);
rows = last_rows = region.rows;
npasses = 1;
if (percent < 100) {
rows = (int)(region.rows * (percent / 100.0));
npasses = region.rows / rows;
last_rows = region.rows - npasses * rows;
if (last_rows)
npasses++;
else
last_rows = rows;
}
cols = region.cols;
G_debug(2, "region.n=%f region.s=%f region.ns_res=%f", region.north,
region.south, region.ns_res);
G_debug(2, "region.rows=%d [box_rows=%d] region.cols=%d", region.rows,
rows, region.cols);
/* using row-based chunks (used for output) when input and output
* region matches and using segment library when they don't */
int use_segment = 0;
int use_base_raster_res = 0;
/* TODO: see if the input region extent is smaller than the raster
* if yes, the we need to load the whole base raster if the -e
* flag was defined (alternatively clip the regions) */
if (base_rast_res_flag->answer)
use_base_raster_res = 1;
if (base_raster_opt->answer && (res_opt->answer || use_base_raster_res
|| extents_flag->answer))
use_segment = 1;
if (base_raster_opt->answer && !use_segment) {
/* TODO: do we need to test existence first? mapset? */
base_raster = Rast_open_old(base_raster_opt->answer, "");
base_raster_data_type = Rast_get_map_type(base_raster);
base_array = G_calloc((size_t)rows * (cols + 1), Rast_cell_size(base_raster_data_type));
}
if (base_raster_opt->answer && use_segment) {
if (use_base_raster_res) {
/* read raster actual extent and resolution */
Rast_get_cellhd(base_raster_opt->answer, "", &input_region);
/* TODO: make it only as small as the output is or points are */
Rast_set_input_window(&input_region); /* we have split window */
} else {
Rast_get_input_window(&input_region);
}
rast_segment_open(&base_segment, base_raster_opt->answer, &base_raster_data_type);
}
if (!scan_flag->answer) {
if (!check_rows_cols_fit_to_size_t(rows, cols))
G_fatal_error(_("Unable to process the hole map at once. "
"Please set the '%s' option to some value lower than 100."),
percent_opt->key);
point_binning_memory_test(&point_binning, rows, cols, rtype);
}
/* open output map */
out_fd = Rast_open_new(outmap, rtype);
/* allocate memory for a single row of output data */
raster_row = Rast_allocate_output_buf(rtype);
G_message(_("Reading data ..."));
count_total = line_total = 0;
/* main binning loop(s) */
for (pass = 1; pass <= npasses; pass++) {
if (npasses > 1)
G_message(_("Pass #%d (of %d) ..."), pass, npasses);
/* figure out segmentation */
row0 = (pass - 1) * rows;
if (pass == npasses) {
rows = last_rows;
}
if (base_array) {
G_debug(2, "filling base raster array");
for (row = 0; row < rows; row++) {
Rast_get_row(base_raster, base_array + ((size_t) row * cols * Rast_cell_size(base_raster_data_type)), row, base_raster_data_type);
}
}
G_debug(2, "pass=%d/%d rows=%d", pass, npasses, rows);
point_binning_allocate(&point_binning, rows, cols, rtype);
line = 0;
count = 0;
counter = 0;
G_percent_reset();
/* loop of input files */
for (i = 0; i < infiles.num_items; i++) {
infile = infiles.items[i];
/* we already know file is there, so just do basic checks */
LAS_reader = LASReader_Create(infile);
if (LAS_reader == NULL)
G_fatal_error(_("Unable to open file <%s>"), infile);
while ((LAS_point = LASReader_GetNextPoint(LAS_reader)) != NULL) {
line++;
counter++;
if (counter == 100000) { /* speed */
if (line < estimated_lines)
G_percent(line, estimated_lines, 3);
counter = 0;
}
/* We always count them and report because behavior
* changed in between 7.0 and 7.2 from undefined (but skipping
* invalid points) to filtering them out only when requested. */
if (!LASPoint_IsValid(LAS_point)) {
n_invalid++;
if (only_valid)
continue;
}
x = LASPoint_GetX(LAS_point);
y = LASPoint_GetY(LAS_point);
if (intens_flag->answer)
/* use intensity as z here to allow all filters (and
* modifications) below to be applied for intensity */
z = LASPoint_GetIntensity(LAS_point);
else
z = LASPoint_GetZ(LAS_point);
int return_n = LASPoint_GetReturnNumber(LAS_point);
int n_returns = LASPoint_GetNumberOfReturns(LAS_point);
if (return_filter_is_out(&return_filter_struct, return_n, n_returns)) {
n_filtered++;
continue;
}
point_class = (int) LASPoint_GetClassification(LAS_point);
if (class_filter_is_out(&class_filter, point_class))
continue;
if (y <= region.south || y > region.north) {
continue;
}
if (x < region.west || x >= region.east) {
continue;
}
/* find the bin in the current array box */
arr_row = (int)((region.north - y) / region.ns_res) - row0;
if (arr_row < 0 || arr_row >= rows)
continue;
arr_col = (int)((x - region.west) / region.ew_res);
z = z * zscale;
if (base_array) {
double base_z;
if (row_array_get_value_row_col(base_array, arr_row, arr_col,
cols, base_raster_data_type,
&base_z))
z -= base_z;
else
continue;
}
else if (use_segment) {
double base_z;
if (rast_segment_get_value_xy(&base_segment, &input_region,
base_raster_data_type, x, y,
&base_z))
z -= base_z;
else
continue;
}
if (zrange_opt->answer) {
if (z < zrange_min || z > zrange_max) {
continue;
}
}
if (intens_import_flag->answer || irange_opt->answer) {
intensity = LASPoint_GetIntensity(LAS_point);
intensity *= iscale;
if (irange_opt->answer) {
if (intensity < irange_min || intensity > irange_max) {
continue;
}
}
/* use intensity for statistics */
if (intens_import_flag->answer)
z = intensity;
}
count++;
/* G_debug(5, "x: %f, y: %f, z: %f", x, y, z); */
update_value(&point_binning, &bin_index_nodes, cols,
arr_row, arr_col, rtype, x, y, z);
} /* while !EOF of one input file */
/* close input LAS file */
LASReader_Destroy(LAS_reader);
} /* end of loop for all input files files */
G_percent(1, 1, 1); /* flush */
G_debug(2, "pass %d finished, %lu coordinates in box", pass, count);
count_total += count;
line_total += line;
/* calc stats and output */
G_message(_("Writing to map ..."));
for (row = 0; row < rows; row++) {
/* potentially vector writing can be independent on the binning */
write_values(&point_binning, &bin_index_nodes, raster_row, row,
cols, rtype, NULL);
/* write out line of raster data */
Rast_put_row(out_fd, raster_row, rtype);
}
/* free memory */
point_binning_free(&point_binning, &bin_index_nodes);
} /* passes loop */
if (base_array)
Rast_close(base_raster);
if (use_segment)
Segment_close(&base_segment);
G_percent(1, 1, 1); /* flush */
G_free(raster_row);
/* close raster file & write history */
Rast_close(out_fd);
sprintf(title, "Raw X,Y,Z data binned into a raster grid by cell %s",
method_opt->answer);
Rast_put_cell_title(outmap, title);
Rast_short_history(outmap, "raster", &history);
Rast_command_history(&history);
Rast_set_history(&history, HIST_DATSRC_1, infile);
Rast_write_history(outmap, &history);
/* set computation region to the new raster map */
/* TODO: should be in the done message */
if (set_region_flag->answer)
G_put_window(®ion);
if (n_invalid && only_valid)
G_message(_("%lu input points were invalid and filtered out"),
n_invalid);
if (n_invalid && !only_valid)
G_message(_("%lu input points were invalid, use -%c flag to filter"
" them out"), n_invalid, only_valid_flag->key);
if (infiles.num_items > 1) {
sprintf(buff, _("Raster map <%s> created."
" %lu points from %d files found in region."),
outmap, count_total, infiles.num_items);
}
else {
sprintf(buff, _("Raster map <%s> created."
" %lu points found in region."),
outmap, count_total);
}
G_done_msg("%s", buff);
G_debug(1, "Processed %lu points.", line_total);
string_list_free(&infiles);
exit(EXIT_SUCCESS);
}
int write_macros(macro_list *pList, FILE *pOutput)
{
int iRetval = 0;
int iLineLength = 0;
if(pList == NULL || pOutput == NULL) {
return(0);
}
if(EOF ==
fputs("\n"
"!if \"$(MANIFEST_LEVEL)\"==\"MACROS\""
"\n",
pOutput))
{
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
return(1);
}
while(pList) {
int bIgnoreForWin16 = 0;
/* The following macros should not be emitted for Win16 */
if (0 == strcmp(pList->m_pMacro, "LINCS")) {
bIgnoreForWin16 = 1;
}
if (bIgnoreForWin16) {
if(0 > fprintf(pOutput, "!if \"$(MOZ_BITS)\" != \"16\"\n")) {
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
iRetval = 1;
break;
}
}
if(0 > fprintf(pOutput, "%s=", pList->m_pMacro)) {
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
iRetval = 1;
break;
}
iLineLength += strlen(pList->m_pMacro) + 1;
iRetval = write_values(pList->m_pValue, pOutput, iLineLength);
if(iRetval) {
break;
}
if(EOF == fputc('\n', pOutput)) {
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
iRetval = 1;
break;
}
iLineLength = 0;
pList = pList->m_pNext;
if (bIgnoreForWin16) {
if(0 > fprintf(pOutput, "!endif\n")) {
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
iRetval = 1;
break;
}
bIgnoreForWin16 = 0;
}
}
if(EOF ==
fputs("\n"
"!endif"
"\n",
pOutput))
{
fprintf(stderr, "MANTOMAK: Error writing to file....\n");
return(1);
}
return(iRetval);
}
int main(int argc, char* argv[])
{
param_t params; /* struct to hold parameter values */
speed_t* cells = NULL; /* grid containing fluid densities */
speed_t* tmp_cells = NULL; /* scratch space */
int* obstacles = NULL; /* grid indicating which cells are blocked */
int* rowsSetup = NULL;
int* accelgrid = NULL;
float* av_vels = NULL; /* a record of the av. velocity computed for each timestep */
int ii, rank, size, tag=0, jj; /* generic counter */
struct timeval timstr; /* structure to hold elapsed time */
struct rusage ru; /* structure to hold CPU time--system and user */
double tic,toc; /* floating point numbers to calculate elapsed wallclock time */
double usrtim; /* floating point number to record elapsed user CPU time */
double systim; /* floating point number to record elapsed system CPU time */
int halorow;
int buff;
int extra;
int start_row;
int end_row;
MPI_Status status;
accel_area_t accel_area;
/* initialise our data structures and load values from file */
initialise(argv[1], &accel_area, ¶ms, &cells, &tmp_cells, &obstacles, &av_vels, &accelgrid);
// Initialize MPI environment.
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
extra = params.ny%size;
halorow = (rank<extra) ? (params.ny/size + 1) * params.nx : (params.ny/size) * params.nx;
calc_row_setup(&rowsSetup, rank, halorow, extra, params);
buff = rowsSetup[0];
start_row = rowsSetup[1];
end_row = rowsSetup[2];
/* iterate for max_iters timesteps */
gettimeofday(&timstr,NULL);
tic=timstr.tv_sec+(timstr.tv_usec/1000000.0);
for(ii=0; ii<params.max_iters; ii++) {
accelerate_flow(params,accel_area,cells,start_row, end_row, accelgrid);
lattice(params,cells,tmp_cells,obstacles, av_vels, start_row, end_row, ii);
}
gettimeofday(&timstr,NULL);
toc=timstr.tv_sec+(timstr.tv_usec/1000000.0);
getrusage(RUSAGE_SELF, &ru);
timstr=ru.ru_utime;
usrtim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
timstr=ru.ru_stime;
systim=timstr.tv_sec+(timstr.tv_usec/1000000.0);
float* buffer = malloc(buff * 9 * sizeof(float));
if(rank != 0) {
for(ii=0; ii<halorow; ii++) {
buffer[9*ii] = cells[start_row+ii].speeds[0];
buffer[9*ii+1] = cells[start_row+ii].speeds[1];
buffer[9*ii+2] = cells[start_row+ii].speeds[2];
buffer[9*ii+3] = cells[start_row+ii].speeds[3];
buffer[9*ii+4] = cells[start_row+ii].speeds[4];
buffer[9*ii+5] = cells[start_row+ii].speeds[5];
buffer[9*ii+6] = cells[start_row+ii].speeds[6];
buffer[9*ii+7] = cells[start_row+ii].speeds[7];
buffer[9*ii+8] = cells[start_row+ii].speeds[8];
}
MPI_Send(buffer, 9*buff, MPI_FLOAT, 0, tag, MPI_COMM_WORLD);
}
else {
if(extra == 0) {
for(ii=1; ii<size; ii++) {
MPI_Recv(buffer, 9*buff, MPI_FLOAT, ii, tag, MPI_COMM_WORLD, &status);
for(jj=0; jj<halorow; jj++) {
cells[halorow*ii+jj].speeds[0] = buffer[9*jj];
cells[halorow*ii+jj].speeds[1] = buffer[9*jj+1];
cells[halorow*ii+jj].speeds[2] = buffer[9*jj+2];
cells[halorow*ii+jj].speeds[3] = buffer[9*jj+3];
cells[halorow*ii+jj].speeds[4] = buffer[9*jj+4];
cells[halorow*ii+jj].speeds[5] = buffer[9*jj+5];
cells[halorow*ii+jj].speeds[6] = buffer[9*jj+6];
cells[halorow*ii+jj].speeds[7] = buffer[9*jj+7];
cells[halorow*ii+jj].speeds[8] = buffer[9*jj+8];
}
}
} else {
for(ii=1; ii<extra; ii++) {
MPI_Recv(buffer, 9*buff, MPI_FLOAT, ii, tag, MPI_COMM_WORLD, &status);
for(jj=0; jj<halorow; jj++) {
cells[halorow*ii+jj].speeds[0] = buffer[9*jj];
cells[halorow*ii+jj].speeds[1] = buffer[9*jj+1];
cells[halorow*ii+jj].speeds[2] = buffer[9*jj+2];
cells[halorow*ii+jj].speeds[3] = buffer[9*jj+3];
cells[halorow*ii+jj].speeds[4] = buffer[9*jj+4];
cells[halorow*ii+jj].speeds[5] = buffer[9*jj+5];
cells[halorow*ii+jj].speeds[6] = buffer[9*jj+6];
cells[halorow*ii+jj].speeds[7] = buffer[9*jj+7];
cells[halorow*ii+jj].speeds[8] = buffer[9*jj+8];
}
}
for(ii=extra; ii<size; ii++) {
MPI_Recv(buffer, 9*buff, MPI_FLOAT, ii, tag, MPI_COMM_WORLD, &status);
for(jj=0; jj<(params.ny/size) * params.nx; jj++) {
int local_extra = halorow * extra + (halorow-params.nx)* (ii-extra);
cells[local_extra + jj].speeds[0] = buffer[9*jj];
cells[local_extra + jj].speeds[1] = buffer[9*jj+1];
cells[local_extra + jj].speeds[2] = buffer[9*jj+2];
cells[local_extra + jj].speeds[3] = buffer[9*jj+3];
cells[local_extra + jj].speeds[4] = buffer[9*jj+4];
cells[local_extra + jj].speeds[5] = buffer[9*jj+5];
cells[local_extra + jj].speeds[6] = buffer[9*jj+6];
cells[local_extra + jj].speeds[7] = buffer[9*jj+7];
cells[local_extra + jj].speeds[8] = buffer[9*jj+8];
}
}
}
free(buffer);
buffer = NULL;
}
MPI_Finalize(); /*Finilize MPI*/
if(rank == 0) {
printf("==done==\n");
printf("Reynolds number:\t\t%.12E\n",calc_reynolds(params,cells,obstacles,av_vels[params.max_iters-1]));
printf("Elapsed time:\t\t\t%.6lf (s)\n", toc-tic);
printf("Elapsed user CPU time:\t\t%.6lf (s)\n", usrtim);
printf("Elapsed system CPU time:\t%.6lf (s)\n", systim);
write_values(params,cells,obstacles,av_vels);
finalise(¶ms, &cells, &tmp_cells, &obstacles, &av_vels, &accelgrid, &rowsSetup);
}
return EXIT_SUCCESS;
}
