fixed small bugs

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"
 

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",
 }