void BSpaceTree::generate_tree(BSpaceNode* node) { //if splitting the node was successful, do the same to the newly //generated child nodes, if they're too big or with a 75% chance. if(split_node(node) != false) { if(node->left->width > max_size || node->left->height > max_size || rand() % 100 > 25) { generate_tree(node->left); } if(node->right->width > max_size || node->right->height > max_size || rand() % 100 > 25) { generate_tree(node->right); } } }
int main() { string policy = "((boy or girl) and student) and ( not man ) "; node * root = generate_tree(policy); search(root); delete_tree(root); return 0; }
BSpaceTree::BSpaceTree(int _height, int _width, int _min_size, int _max_size) { height = _height; width = _width; min_size = _min_size; max_size = _max_size; root = new BSpaceNode(0, 0, height, width); generate_tree(root); }
int main() { Traversal t0 = {TOP_DOWN, print_num}; Traversal t1 = {BOTTOM_UP, print_num}; Traversal tr[2] = {t0,t1}; run_traversals(generate_tree(),traversal_sequence,4); return 0; }
tree_node *generate_tree(char *pre_order, int pre_start, int pre_end, char *in_order, int in_start, int in_end) { if(pre_start > pre_end) return NULL; else if(pre_start == pre_end) return new tree_node(pre_order[pre_start]); else { int i = in_start; while(i <= in_end && in_order[i] != pre_order[pre_start]) ++i; int left = i - in_start; return new tree_node(pre_order[pre_start], generate_tree(pre_order, pre_start + 1, pre_start + left, in_order, in_start, in_start + left - 1), generate_tree(pre_order, pre_start + left + 1, pre_end, in_order, in_start + left + 1, in_end)); } }
Node* generate_tree(std::mt19937& random, int levels, bool is_ghost) { if (levels <= 0) return nullptr; if (levels == 1) { return generate_terminal_node(random, is_ghost); } else { Node* parent = generate_parent_node(random); // Make first child have levels - 1 levels in order to gaurantee `levels` levels parent->children.emplace_back(generate_tree(random, levels - 1, is_ghost)); // Make other children have random between 1, and levels - 1 levels for (int child_index = 1; child_index < parent->GetMinChildren(); ++child_index) { parent->children.emplace_back(generate_tree(random, random_int(random, 1, levels - 1), is_ghost)); } return parent; } }
int main() { char pre_order[50], in_order[50]; while(scanf("%s%s", pre_order, in_order) != EOF) { tree_node *root = generate_tree(pre_order, 0, strlen(pre_order) - 1, in_order, 0, strlen(in_order) - 1); post_order(root); printf("\n"); } return 0; }
//Folgende Argumente werden erwartet: // - die Anzahl Elemente, die in den Baum rein sollen. // - der Typus des Speicher-Layouts // - die Anzahl Such-Iterationen für die Zeiterfassung int main(int argc, char** argv){ //Variablen aus Parameter Layout m_type; unsigned int anzahl_elemente; unsigned int anzahl_such_iterationen; anzahl_elemente = atoi(argv[1]); anzahl_such_iterationen = atoi(argv[3]); if (argv[2] == "RANDOM") m_type = RANDOM; else if (argv[2] == "SORTED") m_type = SORTED; else if (argv[2] == "LAYERS") m_type = LAYERS; else if (argv[2] == "EMDEBOAS") m_type = EMDEBOAS; else{ std::cerr << "Fehler: '" << argv[2] << "' ist kein gültiger Typ" << std::endl; return 2; } //Generiere den Baum Node* my_tree = generate_tree(anzahl_elemente, m_type); //Verwende immer den selben Seed (#Comparable) //ToDo!!! //Beginne Messung der Such-Laufzeit //Starte Zeit clock_t start_zeit = clock(); for(int i = 0; i < anzahl_such_iterationen; i++){ unsigned int random = rand() % anzahl_elemente; if(search_in_tree(my_tree, random)){ continue; }else{ std::cerr << "Schlüssel '" << random << "' konnte nicht gefunden werden!" << std::endl; } } //Stoppe Zeit clock_t end_zeit = clock(); //Zeitdifferenz long gesamtzeit = (long)(((double)(end_zeit - start_zeit) / CLOCKS_PER_SEC)*1000); long zeit_pro_such = gesamtzeit / anzahl_such_iterationen; //Ausgabe std::cout << gesamtzeit << " " << zeit_pro_such << std::endl; return 0; }
static void generate_tree(property_tree &tree, ast_prop const *p, bool positive) { switch (p->type) { case PROP_ATOM: tree->leaves.push_back(property_tree::leave (generate_property(*p->atom, positive), positive)); break; case PROP_IMPL: case PROP_AND: case PROP_OR: { property_tree *dst = &tree; bool conjunction = (p->type == PROP_AND) ^ !positive; if (tree->conjunction != conjunction) { tree->subtrees.push_back(new property_tree::data(conjunction)); dst = &tree->subtrees.back(); } generate_tree(*dst, p->lhs, positive ^ (p->type == PROP_IMPL)); generate_tree(*dst, p->rhs, positive); break; } case PROP_NOT: generate_tree(tree, p->lhs, !positive); break; } }
Node* generate_tree_up_to(std::mt19937& random, int max_levels, bool is_ghost) { if (max_levels <= 0) return nullptr; if (max_levels == 1) { return generate_terminal_node(random, is_ghost); } else { Node* parent = generate_parent_node(random); for (int child_index = 0; child_index < parent->GetMinChildren(); ++child_index) { parent->children.emplace_back(generate_tree(random, random_int(random, 1, max_levels - 1), is_ghost)); } return parent; } }
void tree_usage::test_tree_generator() { tree_traveler_output<char> tto; char preorder[] = "EDBACHFG"; char inorder[] = "ABCDEFGH"; bin_tree<char>* pTree = generate_tree(preorder, inorder, 8); if(pTree) { cout<<"level travel result: "; pTree->travel_level(&tto); cout<<"preorder travel result: "; pTree->travel_RootLR(&tto); cout<<"inorder travel result: "; pTree->travel_LRootR(&tto); } else { cout<<"fail to generate tree!"<<endl; } delete pTree; return; };
void parse_property_tree(property_tree &tree, ast_prop const *p) { tree = new property_tree::data(false); generate_tree(tree, p, true); delete_prop(p); }
/*============================================================================== * MAIN: where everything starts .... *==============================================================================*/ int main(int argc, char **argv) { gridls *grid_list; /* pointer to list of grids */ int no_grids; /* total number of grids */ int no_timestep; /* number of coarse grid timesteps */ int no_first_timestep; /* number of initial timestep */ double timecounter; /* time variable */ double timestep; /* timestep size */ double timecounter_final; /* for all sorts of tests... */ char AMIGA_input[MAXSTRING]; #ifdef WITH_MPI uint64_t newparts; #endif /*============================================================ * we always read the relevant parameters from an input file! *===========================================================*/ if(argc<2) { fprintf(stderr,"usage: %s AMIGA.input\n", argv[0]); fprintf(stderr," or %s --parameterfile\n", argv[0]); exit(1); } /*============================================================ * maybe the user only wants the parameterfile? *===========================================================*/ if(strcmp(argv[1],"--parameterfile") == 0) { global_io.params = (io_parameter_t) calloc(1,sizeof(io_parameter_struct_t)); global_io.params->outfile_prefix = (char *) calloc(MAXSTRING,sizeof(char)); global.a = 1; strcpy(global_io.params->outfile_prefix,"AHF"); write_parameterfile(); exit(0); } else { strcpy(AMIGA_input, argv[1]); } /* check for some DEFINEFLAGS mistakes */ #if (defined NCPUREADING_EQ_NFILES && defined BCASTHEADER) fprintf(stderr,"you cannot define NCPUREADING_EQ_NFILES and BCASTHEADER at the same time\nABORTING\n"); exit(1); #endif #if (!defined WITH_MPI) WRITEAHFLOGO(stderr); #endif /* how much memory per node and particle for this particular run */ global.bytes_node = sizeof(struct node); global.bytes_part = sizeof(struct particle); # ifdef WITH_MPI /* Initialize the MPI environment */ common_initmpi(&argc, &argv); # ifdef MPI_TIMING global_mpi.start = MPI_Wtime(); # endif # endif /*======================================================== * startrun: input the initial data from infile *========================================================*/ timing.io -= time(NULL); timing.startrun -= time(NULL); startrun((argc > 1) ? argv[1] : NULL, &timecounter, ×tep, &no_first_timestep); timing.startrun += time(NULL); #ifdef DEBUG_STARTRUN /*=========================================================== * DEBUG_STARTRUN: * we simply check if the particles have been read correctly *===========================================================*/ { FILE *fpout; char outname[MAXSTRING]; partptr cur_part; #ifdef WITH_MPI sprintf(outname,"test-%d.ascii",global_mpi.rank); #else sprintf(outname,"test.ascii"); #endif fpout = fopen(outname,"w"); for(cur_part=global_info.fst_part; cur_part<(global_info.fst_part+global_info.no_part); cur_part++) fprintf(fpout,"%e %e %e\n",cur_part->pos[X]*simu.boxsize,cur_part->pos[Y]*simu.boxsize,cur_part->pos[Z]*simu.boxsize); fclose(fpout); #ifdef WITH_MPI MPI_Barrier(MPI_COMM_WORLD); #endif //exit(0); } #endif /* DEBUG_STARTRUN */ /*========================================================================================== * AHFptfocus: * * only use a certain type of particles ("pt") and focus ("focus") the AHF analysis on them * *==========================================================================================*/ #if (defined AHFptfocus && defined MULTIMASS && defined GAS_PARTICLES) /* global_info.no_part * global_info.fst_part * => the no. of particles and relevant pointer for this CPU */ timing.ptfocus -= time(NULL); { long unsigned no_part; partptr fst_part, cur_part, new_part; int ikeep; fprintf(stderr,"\n==================================================================\n"); fprintf(stderr," AHFptfocus\n"); fprintf(stderr," ? ARE YOU SURE ABOUT THIS FLAG ?\n"); fprintf(stderr,"==================================================================\n"); fprintf(stderr,"AHF will now remove all particles whose type is not %d\n",AHFptfocus); fprintf(stderr,"starting with %ld particles -> ",global_info.no_part); /* 1. count number of particles to keep */ no_part = 0; for(cur_part=global_info.fst_part; cur_part<(global_info.fst_part+global_info.no_part); cur_part++) { /* we only want ot keep those particles with type AHFptfocus */ if(AHFptfocus == 0) { if(cur_part->u >= AHFptfocus) no_part++; } else { if(fabs(cur_part->u+AHFptfocus) < ZERO) no_part++; } /* only keep the high-resolution particles */ // if(cur_part->u >= 0 || cur_part->u == PDM || cur_part->u == PSTAR) // no_part++; } /* allocate memory for new particles */ fst_part = c_part(no_part); /* 2. remove all other particles */ new_part = fst_part; for(cur_part=global_info.fst_part; cur_part<(global_info.fst_part+global_info.no_part); cur_part++) { ikeep = 0; /* we only want ot keep those particles with type AHFptfocus */ if(AHFptfocus == 0) { if(cur_part->u >= AHFptfocus) ikeep = 1; } else { if(fabs(cur_part->u+AHFptfocus) < ZERO) ikeep = 1; } /* only keep the high-resolution particles */ // if(cur_part->u >= 0 || cur_part->u == PDM || cur_part->u == PSTAR) // ikeep = 1; if(ikeep) { new_part->pos[X] = cur_part->pos[X]; new_part->pos[Y] = cur_part->pos[Y]; new_part->pos[Z] = cur_part->pos[Z]; new_part->mom[X] = cur_part->mom[X]; new_part->mom[Y] = cur_part->mom[Y]; new_part->mom[Z] = cur_part->mom[Z]; new_part->weight = cur_part->weight; new_part->u = cur_part->u; #if (!(defined AHF_NO_PARTICLES && defined AHFlean)) new_part->id = cur_part->id; #endif new_part++; } } /* erase old particle list and store new one */ free(global_info.fst_part); global_info.fst_part = fst_part; /* update global.no_part parameter */ global_info.no_part = no_part; fprintf(stderr,"ended with %ld particles\n\n",global_info.no_part); } timing.ptfocus += time(NULL); #endif /* AHFptfocus */ #ifdef AHFrfocus /*==================================================================== * This is for focussing on a Sphere defined in param.h * This assumes that periodicity can be neglected for deciding * whether a particle is inside the selected sphere or not. *====================================================================*/ timing.rfocus -= time(NULL); local_focusSphere(); timing.rfocus += time(NULL); #endif # if (defined WITH_MPI && defined MPI_TIMING) global_mpi.stop = MPI_Wtime(); io_logging_msg(global_io.log, INT32_C(1), "Startrun done in %fs", global_mpi.stop-global_mpi.start); global_mpi.start = global_mpi.stop; # endif # ifdef WITH_MPI timing.loadbalance -= time(NULL); /* Sort the particles in a particle block structure */ io_logging_section(global_io.log, "Initial Load-Balancing and Particle Distribution"); io_logging_subsection(global_io.log, "Loadbalancing"); loadbalance_update(global_io.log, global_info.loadbal, global_info.fst_part, global_info.no_part); # ifdef MPI_TIMING global_mpi.stop = MPI_Wtime(); io_logging_msg(global_io.log, INT32_C(1), "Loadbalance done in %fs", global_mpi.stop-global_mpi.start); global_mpi.start = global_mpi.stop; # else io_logging_msg(global_io.log, INT32_C(1), "Loadbalance done."); # endif loadbalance_log(global_io.log, global_info.loadbal); timing.loadbalance += time(NULL); # else /* Generate the SFC keys for all particles */ timing.sfckey -= time(NULL); for (uint64_t i=0; i<global_info.no_part; i++) { partptr part=global_info.fst_part+i; part->sfckey = sfc_curve_calcKey(global_info.ctype, (double)(part->pos[0]), (double)(part->pos[1]), (double)(part->pos[2]), BITS_PER_DIMENSION); } /* Sorting all particles to have fast access later on */ qsort(global_info.fst_part, global_info.no_part, sizeof(part), &cmp_sfckey_part); timing.sfckey += time(NULL); # endif /* WITH_MPI*/ # ifdef WITH_MPI timing.distribution -= time(NULL); /* Do a first sort of the particles, required for distributing */ io_logging_subsection(global_io.log, "Sorting particles"); qsort(global_info.fst_part, global_info.no_part, sizeof(part), &cmp_sfckey_part); # ifdef MPI_TIMING global_mpi.stop = MPI_Wtime(); io_logging_msg(global_io.log, INT32_C(1), "Sorting done in %fs", global_mpi.stop-global_mpi.start); global_mpi.start = global_mpi.stop; # else io_logging_msg(global_io.log, INT32_C(1), "Sorting done."); # endif /* Distribute the particles */ io_logging_subsection(global_io.log, "Distributing particles"); io_logging_msg(global_io.log, INT32_C(0), "Currently having %"PRIu64" particles.", global_info.no_part); comm_dist_part(global_io.log, &(global_info.fst_part), &(global_info.no_part), global_info.loadbal); # ifdef MPI_TIMING global_mpi.stop = MPI_Wtime(); io_logging_msg(global_io.log, INT32_C(1), "Distributing done in %fs", global_mpi.stop-global_mpi.start); global_mpi.start = global_mpi.stop; # else io_logging_msg(global_io.log, INT32_C(1), "Distributing done."); # endif io_logging_msg(global_io.log, INT32_C(0), "Having %"PRIu64" particles!", global_info.no_part); /* Do the AHF distribution*/ io_logging_subsection(global_io.log, "AHF distribution (duplicating)"); newparts = comm_dist_part_ahf(global_io.log, &(global_info.fst_part), &(global_info.no_part), global_info.loadbal); io_logging_msg(global_io.log, INT32_C(0), "Received %"PRIu64" new particles.", newparts); /* We need to sort the particles again */ qsort(global_info.fst_part, global_info.no_part, sizeof(part), &cmp_sfckey_part); # ifdef MPI_TIMING global_mpi.stop = MPI_Wtime(); io_logging_msg(global_io.log, INT32_C(1), "AHF distribution done in %fs", global_mpi.stop-global_mpi.start); global_mpi.start = global_mpi.stop; # else io_logging_msg(global_io.log, INT32_C(1), "AHF distribution done."); # endif timing.distribution += time(NULL); # endif /* WITH_MPI */ #ifdef AHFsplit_only /*==================================================================== * we only split the data using the SFC and * dump the data into multilpe files *====================================================================*/ { io_file_t dumpf; io_file_strg_struct_t strg; char *fname; /* Start tge section */ io_logging_section(global_io.log, "Dumping AHF chunk to file"); /* First generate the filename */ fname = (char *)malloc( sizeof(char) *( strlen(global_io.params->outfile_prefix)+30)); if (fname == NULL) { io_logging_memfatal(global_io.log, "filename string"); common_terminate(EXIT_FAILURE); } sprintf(fname, "%s.chunk.%04i.dump", global_io.params->outfile_prefix, global_mpi.rank); io_logging_msg(global_io.log, UINT32_C(0), "Used filename: %s", fname); fflush(NULL); MPI_Barrier(MPI_COMM_WORLD); /* Assign particles to structure */ strg.posx.val = (void *)(global_info.fst_part->pos); strg.posx.stride = (char *)((global_info.fst_part+1)->pos ) - (char *)(global_info.fst_part->pos); strg.posy.val = (void *)(global_info.fst_part->pos+1); strg.posy.stride = (char *)((global_info.fst_part+1)->pos+1) - (char *)(global_info.fst_part->pos+1); strg.posz.val = (void *)(global_info.fst_part->pos+2); strg.posz.stride = (char *)((global_info.fst_part+1)->pos+2) - (char *)(global_info.fst_part->pos+2); strg.momx.val = (void *)(global_info.fst_part->mom); strg.momx.stride = (char *)((global_info.fst_part+1)->mom ) - (char *)(global_info.fst_part->mom); strg.momy.val = (void *)(global_info.fst_part->mom+1); strg.momy.stride = (char *)((global_info.fst_part+1)->mom+1) - (char *)(global_info.fst_part->mom+1); strg.momz.val = (void *)(global_info.fst_part->mom+2); strg.momz.stride = (char *)((global_info.fst_part+1)->mom+2) - (char *)(global_info.fst_part->mom+2); # ifdef MULTIMASS strg.weight.val = (void *)&(global_info.fst_part->weight); strg.weight.stride = (char *)&((global_info.fst_part+1)->weight) - (char *)&(global_info.fst_part->weight); # else strg.weight.val = NULL; strg.weight.stride = (ptrdiff_t)0; # endif /* MULTIMASS */ # ifdef GAS_PARTICLES strg.u.val = (void *)&(global_info.fst_part->u); strg.u.stride = (char *)&((global_info.fst_part+1)->u) - (char *)&(global_info.fst_part->u); # else strg.u.val = NULL; strg.u.stride = (ptrdiff_t)0; # endif /* GAS_PARTICLE */ # if (defined AHFlean && defined AHF_NO_PARTICLES) strg.id.val = NULL; strg.id.stride = (ptrdiff_t)0; # else strg.id.val = &(global_info.fst_part->id); strg.id.stride = (char *)&((global_info.fst_part+1)->id) - (char *)&(global_info.fst_part->id); # endif strg.bytes_float = sizeof(global_info.fst_part->pos[0]); # if (defined AHFlean && defined AHF_NO_PARTICLES) strg.bytes_int = 0; # else strg.bytes_int = sizeof(global_info.fst_part->id); # endif /* Open the dump file now */ dumpf = io_file_open(global_io.log, fname, IO_FILE_ARES, IO_FILE_UNKOWN_SWAPPING, IO_FILE_WRITE, 0); /* Write the particles */ io_file_writepart(global_io.log, dumpf, 0, global_info.no_part, strg); /* Set the header values */ ((io_ares_t)dumpf)->header->no_part = (uint64_t)simu.no_part; ((io_ares_t)dumpf)->header->no_species = UINT64_C(0); ((io_ares_t)dumpf)->header->no_vpart = simu.no_vpart; ((io_ares_t)dumpf)->header->boxsize = simu.boxsize; ((io_ares_t)dumpf)->header->omega0 = simu.omega0; ((io_ares_t)dumpf)->header->lambda0 = simu.lambda0; ((io_ares_t)dumpf)->header->pmass = simu.pmass; ((io_ares_t)dumpf)->header->minweight = simu.min_weight; ((io_ares_t)dumpf)->header->maxweight = simu.max_weight; ((io_ares_t)dumpf)->header->a_initial = simu.a_initial; ((io_ares_t)dumpf)->header->a_current = global.a; ((io_ares_t)dumpf)->header->timestep = timestep; ((io_ares_t)dumpf)->header->minkey = global_info.loadbal->fstkey[global_mpi.rank]; ((io_ares_t)dumpf)->header->maxkey = global_info.loadbal->lstkey[global_mpi.rank]; ((io_ares_t)dumpf)->header->lb_level = global_info.loadbal->level; ((io_ares_t)dumpf)->header->rank = global_mpi.rank; ((io_ares_t)dumpf)->header->size = global_mpi.size; /* Log the file */ io_file_log(global_io.log, dumpf); /* Close the file and clean up*/ io_file_close(global_io.log, &dumpf); free(fname); } common_terminate(EXIT_SUCCESS); #endif /* AHFsplit_only */ #ifdef AHF_DUMP_AFTER_READ_TO_ASCII /*==================================================================== * write an ASCII file of the data just read *====================================================================*/ { FILE *dumpf; char *fname; /* First generate the filename */ fname = (char *)malloc( sizeof(char) *( strlen(global_io.params->outfile_prefix)+35)); if (fname == NULL) { io_logging_memfatal(global_io.log, "filename string"); common_terminate(EXIT_FAILURE); } #ifdef WITH_MPI sprintf(fname, "%s.chunk.%04i.ascii", global_io.params->outfile_prefix, global_mpi.rank); #else sprintf(fname, "%s.DUMP.ascii", global_io.params->outfile_prefix); #endif io_logging_msg(global_io.log, UINT32_C(0), "Used filename: %s", fname); fflush(NULL); #ifdef WITH_MPI MPI_Barrier(MPI_COMM_WORLD); #endif dumpf = fopen(fname, "w"); fprintf(dumpf, "# x y z vx vy vz ID\n"); for (uint64_t i=0L; i<global_info.no_part; i++) { fprintf(dumpf, "%15e %15e %15e %15e %15e %15e %lu\n", global_info.fst_part[i].pos[0], global_info.fst_part[i].pos[1], global_info.fst_part[i].pos[2], global_info.fst_part[i].mom[0], global_info.fst_part[i].mom[1], global_info.fst_part[i].mom[2], (unsigned long)global_info.fst_part[i].id); } fclose(dumpf); common_terminate(EXIT_SUCCESS); } #endif #ifdef WITH_MPI loadbalance_minimalMemory(global_io.log, global_info.loadbal); #endif io_logging_msg(global_io.log, INT32_C(5), "amiga_main: running with %" PRIu64 " particles", global_info.no_part); io_logging_part(global_io.log, "Handing over logging to AMIGA"); timing.io += time(NULL); /*===================================================================== * at this point we completely read in the data file * and are ready to proceed with generating the * grid hierarchy or what else we plan to do... *=====================================================================*/ /*==================================================================== * GENERATE THE FULL BLOWN AMR HIERARCHY AND ORGANIZE IT INTO A TREE *====================================================================*/ #ifdef NEWAMR /* 1. organize the particles into a tree */ generate_tree(global_info.no_part, global_info.fst_part, simu.Nth_dom); /* 2. percolate the tree to find isolated patches on each level */ /* 3. transfer isolated patches to halo structures */ #else /* NEWAMR */ /*===================================================================== * generate the domain grids: simu.NGRID_MIN^3, ...., simu.NGRID_DOM^3 *=====================================================================*/ timing.gendomgrids -= time(NULL); grid_list = gen_domgrids(&no_grids); timing.gendomgrids += time(NULL); /*===================================================================== * build initial linked list *=====================================================================*/ timing.ll -= time(NULL); ll(global_info.no_part, global_info.fst_part, global.dom_grid); global.fst_part = global_info.fst_part; global.no_part = global_info.no_part; timing.ll += time(NULL); /*================================================================ * assign particles to the domain grid with simu.NGRID_DOM^3 nodes *================================================================*/ zero_dens(global.dom_grid); assign_npart(global.dom_grid); /*================================================================ * initialize some counters *================================================================*/ no_timestep = no_first_timestep+1; /* count total number of integration steps */ global.total_time = 0.; /* cumulative total time for simulation */ global.output_count = 0; /* count the number of outputs */ /* make *current* time step available to AHF/etc. routines */ global.no_timestep = no_first_timestep; /*========================================================================================= * recursively call gen_AMRhierarchy() to generate the AMR hierarchy... *=========================================================================================*/ global.fst_cycle = TRUE; gen_AMRhierarchy(&grid_list, &no_grids); /*========================================================================================= * eventually perform AHF analysis of AMR hierarchy *=========================================================================================*/ ahf.time -= time(NULL); /* get spatially connected refinement patches */ timing.ahf_gridinfo -= time(NULL); ahf_gridinfo(grid_list, no_grids-1); timing.ahf_gridinfo += time(NULL); /* get AHF halos */ timing.ahf_halos -= time(NULL); ahf_halos(grid_list); timing.ahf_halos += time(NULL); ahf.time += time(NULL); /*========================================================================================= * update logfile and say bye-bye *=========================================================================================*/ write_logfile(timecounter, timestep, no_timestep); /* free all allocated memory... */ free(grid_list); #endif /* NEWAMR */ /*============================================================================ * BYE BYE! *============================================================================*/ free(io.icfile_name); free(io.dumpfile_name); free(io.logfile_name); free(io.outfile_prefix); free(global.termfile_name); free(global.fst_part); if(global.fst_gas) free(global.fst_gas); if(global.fst_star) free(global.fst_star); fprintf(io.logfile, "==========================================================\n"); fprintf(io.logfile, " FINISHED (v%3.1f/%03d)\n",VERSION,BUILD); fprintf(io.logfile, "==========================================================\n"); fclose(io.logfile); # ifdef WITH_MPI /* Gracefully terminate MPI */ MPI_Finalize(); # endif return EXIT_SUCCESS; }