diff --git a/binarycpython/utils/grid.py b/binarycpython/utils/grid.py
index 82a1f91f47c878c74b5031689cffadc61d7acd78..f8d309251ada4cba12a62ee8ef01afc30652df16 100644
--- a/binarycpython/utils/grid.py
+++ b/binarycpython/utils/grid.py
@@ -696,7 +696,11 @@ class Population:
# Log and print some information
verbose_print(
- "Population-{} finished!".format(self.grid_options["_population_id"]),
+ "Population-{} finished! It took a total of {}s to run {} systems on {} cores".format(
+ self.grid_options["_population_id"],
+ self.grid_options['_end_time_evolution']-self.grid_options['_start_time_evolution'],
+ self.grid_options['_total_starcount'],
+ self.grid_options['amt_cores']),
self.grid_options["verbosity"],
0,
)
@@ -723,6 +727,8 @@ class Population:
self.grid_options["verbosity"],
0,
)
+ else:
+ verbose_print("There were no errors found in this run.", self.grid_options["verbosity"], 0)
##
# Clean up code: remove files, unset values.
@@ -745,11 +751,13 @@ class Population:
self._load_grid_function()
# Set up generator
- generator = self.grid_options["_system_generator"](self)
+ generator = self.grid_options["_system_generator"](self, print_results=False)
# Set up local variables
running = True
- localcounter = 0
+ localcounter = 0 # global counter for the whole loop. (need to be ticked every loop)
+ probability_of_systems_run = 0 # counter for the probability of the actual systems this tread ran
+ number_of_systems_run = 0 # counter for the actual amt of systems this thread ran
verbose_print(
"Process {} started".format(ID), self.grid_options["verbosity"], 0
@@ -778,16 +786,18 @@ class Population:
# Evolve the system
self._evolve_system_mp(full_system_dict)
+ # TODO: fix the 'repeat' and 'weight' tracking here
+ # Keep track of systems:
+ probability_of_systems_run += full_system_dict['probability']
+ number_of_systems_run += 1
+
except StopIteration:
- verbose_print(
- "Process {}: generator done".format(ID),
- self.grid_options["verbosity"],
- 0,
- )
running = False
+ # Has to be here because this one is used for the (localcounter+ID) % (self..)
localcounter += 1
+
# Return a set of results and errors
output_dict = {
"results": self.grid_options["results"],
@@ -800,6 +810,12 @@ class Population:
"_errors_found": self.grid_options["_errors_found"],
}
+ verbose_print(
+ "Process {}: generator done. Ran {} systems with a total probability of {}. This thread had {} failing systems with a total probability of {}".format(ID, number_of_systems_run, probability_of_systems_run, self.grid_options["_failed_count"], self.grid_options["_failed_prob"]),
+ self.grid_options["verbosity"],
+ 0,
+ )
+
return output_dict
def _evolve_population_mp(self):
@@ -1132,7 +1148,8 @@ class Population:
# TODO: add centering center left right for the spacing.
# TODO: add sensible description to this function.
# TODO: Check whether all the probability and phasevol values are correct.
-
+ # TODO: import only the necessary packages/functions
+
Results in a generated file that contains a system_generator function.
"""
@@ -1153,7 +1170,7 @@ class Population:
code_string += "\n\n"
# Make the function
- code_string += "def grid_code(self):\n"
+ code_string += "def grid_code(self, print_results=True):\n"
# Increase depth
depth += 1
@@ -1191,8 +1208,8 @@ class Population:
code_string += indent * depth + "phasevol = 1\n"
code_string += indent * depth + "\n"
- code_string += indent * depth + "# setting probability lists\n"
# Prepare the probability
+ code_string += indent * depth + "# setting probability lists\n"
for grid_variable_el in sorted(
self.grid_options["_grid_variables"].items(),
key=lambda x: x[1]["grid_variable_number"],
@@ -1400,26 +1417,36 @@ class Population:
# Calculate value
code_string += (
indent * (depth + 1)
- + 'probability = self.grid_options["_weight"] * probabilities_list[{}]'.format(
+ + 'probability = self.grid_options["weight"] * probabilities_list[{}]'.format(
grid_variable["grid_variable_number"]
)
+ "\n"
)
+ # TODO: ask rob if just replacing this with probability is enough
code_string += (
indent * (depth + 1)
- + 'repeat_probability = probability / self.grid_options["_repeat"]'
+ # + 'repeat_probability = probability / self.grid_options["repeat"]'
+ + 'probability = probability / self.grid_options["repeat"]'
+ "\n"
)
- code_string += indent * (depth + 1) + "_total_starcount += 1\n"
- # set probability and phasevol values
+ # For each repeat of the system this has to be done yes.
code_string += (
indent * (depth + 1)
+ + 'for _ in range(self.grid_options["repeat"]):'
+ + "\n"
+ )
+
+ code_string += indent * (depth + 2) + "_total_starcount += 1\n"
+
+ # set probability and phasevol values
+ code_string += (
+ indent * (depth + 2)
+ 'parameter_dict["{}"] = {}'.format("probability", "probability")
+ "\n"
)
code_string += (
- indent * (depth + 1)
+ indent * (depth + 2)
+ 'parameter_dict["{}"] = {}'.format("phasevol", "phasevol")
+ "\n"
)
@@ -1434,13 +1461,13 @@ class Population:
# Increment total probability
code_string += (
- indent * (depth + 1) + "self._increment_probtot(probability)\n"
+ indent * (depth + 2) + "self._increment_probtot(probability)\n"
)
if not dry_run:
# Handling of what is returned, or what is not.
# TODO: think of whether this is a good method
- code_string += indent * (depth + 1) + "yield(parameter_dict)\n"
+ code_string += indent * (depth + 2) + "yield(parameter_dict)\n"
# The below solution might be a good one to add things to specific queues
# $self->queue_evolution_code_run($self->{_flexigrid}->{thread_q},
@@ -1448,7 +1475,7 @@ class Population:
# If its a dry run, dont do anything with it
else:
- code_string += indent * (depth + 1) + "pass\n"
+ code_string += indent * (depth + 2) + "pass\n"
code_string += indent * (depth + 1) + "#" * 40 + "\n"
@@ -1490,13 +1517,20 @@ class Population:
code_string += indent * (depth + 1) + "#" * 40 + "\n"
code_string += (
indent * (depth + 1)
+ + "if print_results:\n"
+ )
+ code_string += (
+ indent * (depth + 2)
+ "print('Grid has handled {} stars'.format(_total_starcount))\n"
)
code_string += (
- indent * (depth + 1)
+ indent * (depth + 2)
+ "print('with a total probability of {}'.format(self.grid_options['_probtot']))\n"
)
+ ################
+ # Finalising return statement for dry run.
+ #
if dry_run:
code_string += indent * (depth + 1) + "return _total_starcount\n"
diff --git a/binarycpython/utils/grid_options_defaults.py b/binarycpython/utils/grid_options_defaults.py
index 96f4c0dc4b9c5e16304c28b4f906dfcd695e081e..5f156624aae6bbaa38f98316745ccb8b92a4a68c 100644
--- a/binarycpython/utils/grid_options_defaults.py
+++ b/binarycpython/utils/grid_options_defaults.py
@@ -88,8 +88,8 @@ grid_options_defaults_dict = {
"_count": 0, # count of systems
"_total_starcount": 0, # Total count of systems in this generator
"_probtot": 0, # total probability
- "_weight": 1.0, # weighting for the probability
- "_repeat": 1.0, # number of times to repeat each system (probability is adjusted to be 1/repeat)
+ "weight": 1.0, # weighting for the probability
+ "repeat": 1, # number of times to repeat each system (probability is adjusted to be 1/repeat)
"results": {}, # dict to store the results. Every process fills this on its own and then it will be joined later
"_start_time_evolution": 0, # Start time of the grid
"_end_time_evolution": 0, # end time of the grid
@@ -466,8 +466,8 @@ grid_options_descriptions = {
"slurm": "Int flag whether to use a slurm type population evolution.", # TODO: describe this in more detail
"population_type": "variable storing what kind of population type should be evolved. See population_type_options for the options.", # TODO: make this functionality work properly
"_population_type_options": "List storing the population_type options.",
- "_weight": "Weight factor for each system. The calculated probability is mulitplied by this. If the user wants each system to be repeated several times, then this variable should not be changed, rather change the _repeat variable instead, as that handles the reduction in probability per system. This is useful for systems that have a process with some random element in it.", # TODO: add more info here, regarding the evolution splitting.
- "_repeat": "Factor of how many times a system should be repeated. Consider the evolution splitting binary_c argument for supernovae kick repeating.", # TODO: make sure this is used.
+ "weight": "Weight factor for each system. The calculated probability is mulitplied by this. If the user wants each system to be repeated several times, then this variable should not be changed, rather change the _repeat variable instead, as that handles the reduction in probability per system. This is useful for systems that have a process with some random element in it.", # TODO: add more info here, regarding the evolution splitting.
+ "repeat": "Factor of how many times a system should be repeated. Consider the evolution splitting binary_c argument for supernovae kick repeating.", # TODO: make sure this is used.
"evolution_type": "Variable containing the type of evolution used of the grid. Multiprocessing or linear processing",
}