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;
}
