def tournament(self,population,data,dataEvaluation,heuristicStrategy,attributeCount): gladiators = Population(self.gladiator,data,dataEvaluation,False,heuristicStrategy) for index in range(self.gladiator): chosenOne = random.randint(0,population.size()-1) gladiators.saveIndividuals(index,population.getIndividual(chosenOne)) morpheus = gladiators.getFittest() return morpheus
def run_synth_test(): """ Run a test with synthetic data and MCMC inference """ # Parse command line args (options, args) = parse_cmd_line_args() print "Creating master population object" model = make_model(options.model, N=options.N) popn = Population(model) results_file = os.path.join(options.resultsDir, "geweke_results.pkl") if os.path.exists(results_file) and not options.force_recompute: with open(results_file) as f: x_smpls = cPickle.load(f) else: x0 = popn.sample() data = gen_synth_data(popn, x0, options.N, options.T) popn.set_data(data) # Perform inference N_samples = 1000 x_smpls = geweke_test(popn, data, N_samples=N_samples) # Save results print "Saving results to %s" % results_file with open(results_file, "w") as f: cPickle.dump(x_smpls, f, protocol=-1) # Plot empirical parameter distributions print "Plotting results." plot_geweke_results(popn, x_smpls, model, resdir=options.resultsDir)
def tourney(self): tourneyPop = Population(Breeder.tourneySize, False) for i in xrange(self.pop.size()): tourneyPop.addIndividual( self.pop.individuals[random.randrange(0,self.pop.size())] ) return tourneyPop.getFittest()
def test_evalutaion(self): pop1 = Population(4) result = pop1.evaluate() self.assertEqual(len(pop1.fitness_table), 4) self.assertEqual(pop1.fitness_table, result) self.assertIn(pop1.pop[0].fitness, [0, 1]) self.assertEqual(pop1.pop[0].fitness, result[0])
class TestPopulationBitstring(unittest.TestCase): def setUp(self): bit0 = Bitstring("0000") bit1 = Bitstring("1111") col0 = ColicinBit(bit0) col1 = ColicinBit(bit1) org = Organism([col0], [ImmunityBit(bit0, 2)]) self.pop = Population([org for _ in range(5)]) def test_replicate(self): self.assertEqual(len(self.pop), 5) self.pop.replicate() self.assertEqual(len(self.pop), 10) def test_remove_self_toxic(self): self.assertEqual(len(self.pop), 5) self.pop.remove_self_toxic() self.assertEqual(len(self.pop), 5) def test_cull_by_iterative_colicin(self): self.assertEqual(len(self.pop), 5) self.pop.cull_by_iterative_colicin() self.assertEqual(len(self.pop), 5) def test_advance_generation(self): self.pop.advance_generation() def test_sample_with_replacement(self): self.pop.sample_with_replacement()
def test_evolve(self): pop1 = Population(4) pop1.evolve() self.assertEqual(len(pop1.pop), 4) self.assertEqual(pop1.selected, []) self.assertEqual(pop1.selected_indexes, []) self.assertEqual(pop1.fitness_table, [])
def test_population_step(self): p = Population() data_before = p.data[:] size_before = len(p) p.step() self.assertEqual(len(p.data), size_before) self.assertNotEqual(p.data, data_before)
class AI: def __init__(self): self.score = 0 self.count = 0 self.population = Population(10) def restart_game(self): if self.score > 0: print("{ ind_score: " + str(self.score) + " }") self.count += 1 self.population.get_cur().score = self.score self.population.go_next() def get_allowed_moves(self, board): allowed = [False, False, False, False] for x in range(0, 4): for y in range(0, 4): if board[y][x] != None: if y < 3 and board[y + 1][x] in (None, board[y][x]): allowed[0] = True # DOWN if y > 0 and board[y - 1][x] in (None, board[y][x]): allowed[1] = True # UP if x > 0 and board[y][x - 1] in (None, board[y][x]): allowed[2] = True # LEFT if x < 3 and board[y][x + 1] in (None, board[y][x]): allowed[3] = True # RIGHT return allowed def get_move(self, score, board): self.score = score features = feature_reader.extract_features(board) g = self.population.get_cur() return g.decide(features, self.get_allowed_moves(board))
def test_advance(self): big_pop = Population( [MockOrganism(1), MockOrganism(2), MockOrganism(90)], 3) big_pop.advance_generation() self.assertLessEqual(len(big_pop), 3)
def test_leastfit_removal(self): this_pop = Population([MockOrganism(1), MockOrganism(2), MockOrganism(100)], carrying_capacity=1) this_pop.remove_least_fit() self.assertIn(this_pop[0].eval_fit(), [1, 2, 100]) self.assertEqual(len(this_pop), 1)
def test_normal_random_population_creation(self): # XXX: I suppose it's possible these asserts could fail because we're dealing with # probabalistic outcomes; I haven't taken the time to prove these always work p = Population() p.randomize(1024) self.assertLess(len(p.coaches), len(p.students)) self.assertLess(len(p.studying_coaches), len(p.coaches)) self.assertLess(1, max([len(u.coaches()) for u in p.students]))
def tournament_selection(self, pop): tournament = Population(self._tournament_size, False) for i in xrange(self._tournament_size): random_id = int(random.random() * pop.population_size()) tournament.save_tour(i, pop.get_tour(random_id)) return tournament.get_fittest()
def colicin_int_demo(): org = Organism([Colicin(0)], [Immunity(0, 5)]) pop = Population(org for _ in range(5)) for gen in range(1000): pop.advance_generation() average_id = average_colicin_int(pop) if gen % 100 == 0: print("{}\t{}".format(gen, average_id))
def create(self): population = Population() population.chromosomes = [self.chromosomeFactory.create() for _ in xrange(self.populationSize)] population.fitnessFunction = self.fitnessFunction return population
def sample_network_from_prior(model): """ Sample a network from the prior """ popn = Population(model) x_true = popn.sample() A_true = x_true['net']['graph']['A'] return popn, x_true, A_true
def test_pessimistic_random_population_creation(self): p = Population() # 10 students who are all infected, all teachers, and all study p.randomize(10, infect_rate=1, feature='A', coach_rate=1, coach_study_rate=1) self.assertEqual(10, p.N) self.assertEqual(p.N, len(p.population)) self.assertEqual(len(p.population), len(p.infected)) self.assertEqual(len(p.infected), len(p.students)) self.assertEqual(len(p.students), len(p.coaches))
def tournament_selection(self, population): population_size = len(population.individuals) tournament = Population(self.tournament_size, False) for i in range(0, self.tournament_size): randomId = int(random() * population_size) tournament.individuals.append(population.individuals[randomId]) return tournament.get_fittest()
def tournament_selection(population): from random import random tournament = Population(tournament_size, False, population.tour_manager) for i in range(0, tournament_size): random_id = (int) (random() * tournament_size) tournament.save_tour(i, population.get_tour(random_id)) fittest = tournament.get_fittest() return fittest
def evolve(target, replace): replacements = 0 population = Population(500, target) while population.max_fitness() < len(target): replace(population) replacements = replacements + 1 print("After",replacements,"replacements, the best individual is \"" + str(population.best_individual()) + "\".")
def initialize_client(model, data): """ Initialize a population objsect on the client """ # Initialize a model with N neurons print "Initializing GLM" global popn popn = Population(model) # Initialize the GLM with the data popn.set_data(data)
def main(duration=10, pop_size=6): population = Population(pop_size) for i in range(duration): population.reproduce() population.survive() print([x.phenotype for x in population]) genetic = [ind.genotype for ind in population] print(genetic)
def main(): population = Population() fittest = population.fittest save(fittest) while True: time.sleep(0.5) population.nextGen() print 'Generation #{} fittest.weight: {} fittest.fitness: {}'.format(population.generation_counter, population.fittest.weight, population.fittest.fitness) if population.fittest.fitness > fittest.fitness: fittest = population.fittest save(fittest)
def test_selection(self): pop1 = Population(4) result = pop1.evaluate() indexes, selected = pop1.selection() self.assertEqual(pop1.selected_indexes, indexes) self.assertEqual(pop1.selected, selected) self.assertEqual(len(selected), 2) self.assertEqual(len(indexes), 2) for ind in selected: self.assertEqual(ind.fitness, 1) for i in indexes: self.assertEqual(pop1.pop[i].fitness,1)
def makeNewGeneration(self): new_population = Population() elected = self.population.getTheBest() new_population.add(elected) while len(new_population) < self.population_size: couple = self.population.selectACouple() child = Person.copulate(couple['man'], couple['woman'], self.contrainsts) if child is not None: new_population.add(child) self.population = new_population
def evolve(self): newPop = Population(self.pop.size(), False) i = 0 while i < self.pop.size(): ind1 = self.tourney() ind2 = self.tourney() newInd = self.breed(ind1, ind2) newPop.addIndividual(newInd) i += 1 return newPop
def colicin_bitstring_demo(): mutate.mutation_rate = 0.05 bit = Bitstring("0000000000000000000") bit2 = Bitstring("1000000000000000000") col = ColicinBit(bit) imm = ImmunityBit(bit2, 1) org = Organism([col], [imm, imm]) pop = Population(org for _ in range(100)) for gen in range(101): pop.advance_generation() if gen % 10 == 0: average_dist = average_colicin_bitstring_distance(pop, col) print("{}\t{}".format(gen, average_dist))
def next_generation(self): self.world.stop() self.population.evaluate() new_pop = Population(rank_probability=self.RANK_PROBABILITY_CONSTANT, reverse_sort=False) for _ in xrange(self.RANDOM_ACTORS_NUMBER): new_pop.append(self.create_actor()) for _ in xrange(self.POP_SIZE - self.RANDOM_ACTORS_NUMBER): new_genotype = Genotype.reproduce(self.population.select_by_rank().genotype, self.population.select_by_rank().genotype) new_pop.append(self.create_actor(genotype=new_genotype)) self.population = new_pop self.current_generation += 1 self.world.start()
class Environment(): contrainsts = None turns = 1000 convergence = 100 population = None population_size = 20 def __init__(self, filename=None, population_size=20, turns=100000, convergence=0.97): if filename is None: self.contrainsts = Event(size=20) else: self.contrainsts = Event(filename=filename) self.turns = turns self.convergence = convergence self.population_size = population_size def generatePopulation(self): self.population = Population(self.population_size, self.contrainsts) def makeNewGeneration(self): new_population = Population() elected = self.population.getTheBest() new_population.add(elected) while len(new_population) < self.population_size: couple = self.population.selectACouple() child = Person.copulate(couple['man'], couple['woman'], self.contrainsts) if child is not None: new_population.add(child) self.population = new_population def adapt(self): self.generatePopulation() #best_person = self.population.getTheBest() for turn in range(self.turns): self.makeNewGeneration() person = self.population.getTheBest() #convergence = self.population.calculateConvergence() #print "convergence is: "+str(convergence) print " i: "+str(turn)+" person "+str(person) #if person.weight < best_person.weight: # best_person = person #if convergence >= self.convergence: # break return self.population.getTheBest()
def run(): cities = preprocessData("berlin.tsp") pop = Population(cities, GENERATION_SIZE) history = [] i = 0 best = pop.getBestMember().length() for j in range(SIMULATED_POPULATION_COUNT): # get next generation pop = pop.copyPopulation() pop.crossover(CROSSOVER_COUNT, CROSSOVER_SIZE_MIN, CROSSOVER_SIZE_MAX) pop.mutate(GENERATION_SIZE-CROSSOVER_COUNT, MUTATE_COUNT) best_member = pop.getBestMember() new_fitness = best_member.length() history.append(new_fitness) if(best > new_fitness): best = new_fitness if(PLOT_PATH): gra = int(122) plt.clf() for c in best_member._cities: plt.plot([c.x], [c.y], color="red", aa=True, marker="o") plt.annotate(int(c.name), (c.x, c.y), color="red") plt.title('Fitness = %.2fkm' % new_fitness) best_member.draw(plt, "#%02x%02x%02x" % (gra, gra, gra)) plt.savefig("stats/fig%s.png" % i) i += 1 return history
def transpogen(cipher, generations, individuals, size): start = time.time() print '[*] Genetic algorithm of {} individuals over {} generations'.format(individuals, generations) print '[*] Start at {}\n'.format(time.strftime('%X')) p = Population(cipher, individuals, size) for i in range(generations): p.generation() print '[+] ### Generation {} ### {}'.format(i, p) print '\n[*] End at {} ({} seconds)'.format(time.strftime('%X'), round(time.time() - start, 2)) print '[*] Best solution is {}'.format(p.best()) with open('plain.text', 'w') as solution_file: solution_file.write(p.plaintext())
for j in range(int(col / 2), col): specimen_c.genotype_matrix[i][j] = specimen_b.genotype_matrix[i][j] return specimen_c amount_of_species = 10 available_values = [1, 2, 5, 10, 20, 50] statistical_day = np.random.random_integers(99, size=(10)) coin_to_save = [2, 5] quantity_of_coins = 2 #rozmiar coin_to_save expected_quantity_of_coins = [ 1, 2 ] #oczekiwana ilosc wydanych nominalow ktore chcemy zachowac population = Population(amount_of_species, statistical_day) population.calculate_changes_for_specimens(available_values) population.rank() population.calculate_cost(coin_to_save, quantity_of_coins, expected_quantity_of_coins) population.show_sorted_population_and_cost() print("\n\n") spec = Genotype() spec = cross_mc(population.population[0], population.population[1]) print(spec.genotype_matrix) for i in range(10): population.cross(coin_to_save, amount_of_species) population.calculate_cost(coin_to_save, quantity_of_coins, expected_quantity_of_coins)
class Game(arcade.Window): def __init__(self, width, height, title): super().__init__(width, height, title) self.gap_factor = 0.25 self.top = self.height / 2 + self.gap_factor * self.height self.middle = self.height / 2 self.bottom = self.height / 2 - self.gap_factor * self.height self.show_game = True self.enemy_list = [] self.frame_counter = 0 self.display_info = True self.pop = Population(250, self) arcade.set_background_color(arcade.color.BLACK_OLIVE) def on_draw(self): """Called whenever we need to draw the window.""" arcade.start_render() if not self.show_game: return players = [player for player in self.pop.pop.copy() if not player.dead] players.sort(key=lambda x: x.fitness, reverse=True) players_to_draw = min(len(players), 5) for i in range(players_to_draw): players[i].draw() if not self.pop.done(): arcade.draw_text( f"Generation {self.pop.gen}\n\n" + f"Overall best score: {self.pop.best_score}", 0.01 * self.width, 0.01 * self.height, arcade.color.WHITE, 14) arcade.draw_text("Current top player\n\n" + f"Score: {players[0].score}\n" + f"Fitness: {players[0].fitness}", 0.99 * self.width, 0.01 * self.height, arcade.color.WHITE, 14, align='right', anchor_x='right') for enemy in self.enemy_list: enemy.draw() def on_update(self, delta_time): if self.pop.done() != True: self.frame_counter += 1 if (self.frame_counter % 30 == 0): location = [self.bottom, self.middle, self.top] index = random.randrange(len(location)) enemy = Enemy(self.width, location[index]) self.enemy_list.append(enemy) for i, enemy in enumerate(self.enemy_list): enemy.update() if enemy.dead: del self.enemy_list[i] self.enemy_list[:] = [ enemy for enemy in self.enemy_list if not enemy.dead ] self.pop.update_alive() if self.display_info == True: print(f"Gen {self.pop.gen}") print(f"Best score: {self.pop.best_score}") self.display_info = False else: self.pop.natural_selection() self.reset_enemies() self.display_info = True def on_key_press(self, key, modifiers): """Called whenever the user presses a key.""" if key == arcade.key.H: self.show_game = not self.show_game def on_key_release(self, key, modifiers): """Called whenever a user releases a key.""" def reset_enemies(self): del self.enemy_list[:]
def run(pop, surveyList, nostdout=False, allsurveyfile=False, scint=False, accelsearch=False, jerksearch=False): """ Run the surveys and detect the pulsars.""" # print the population if not nostdout: print "Running doSurvey on population..." print pop # loop over the surveys we want to run on the pop file surveyPops = [] for surv in surveyList: s = Survey(surv) s.discoveries = 0 if not nostdout: print "\nRunning survey {0}".format(surv) # create a new population object to store discovered pulsars in survpop = Population() # HERE SHOULD INCLUDE THE PROPERTIES OF THE ORIGINAL POPULATION # counters nsmear = 0 nout = 0 ntf = 0 ndet = 0 # loop over the pulsars in the population list for psr in pop.population: # pulsar could be dead (evolve!) - continue if so if psr.dead: continue # is the pulsar over the detection threshold? snr = s.SNRcalc(psr, pop) # add scintillation, if required # modifying S/N rather than flux is sensible because then # a pulsar can have same flux but change S/N in repeated surveys if scint: snr = s.scint(psr, snr) if snr > s.SNRlimit: ndet += 1 psr.snr = snr survpop.population.append(psr) # check if the pulsar has been detected in other # surveys if not psr.detected: # if not, set to detected and increment # number of discoveries by the survey psr.detected = True s.discoveries += 1 elif snr == -1.0: nsmear += 1 elif snr == -2.0: nout += 1 else: ntf += 1 # report the results if not nostdout: print "Total pulsars in model = {0}".format(len(pop.population)) print "Number detected by survey {0} = {1}".format(surv, ndet) print "Of which are discoveries = {0}".format(s.discoveries) print "Number too faint = {0}".format(ntf) print "Number smeared = {0}".format(nsmear) print "Number out = {0}".format(nout) print "\n" d = Detections(ndet=ndet, ntf=ntf, nsmear=nsmear, nout=nout, ndisc=s.discoveries) surveyPops.append([surv, survpop, d]) if allsurveyfile: allsurvpop = Population() allsurvpop.population = [psr for psr in pop.population if psr.detected] surveyPops.append([None, allsurvpop, None]) return surveyPops
class GPAlgorithm: def __init__(self, f, nrInd): self.n = 0 self.input = [] self.output = [] self.inputTest = [] self.outputTest = [] self.inputTrain = [] self.outputTrain = [] self.filename = f self.nrInd = nrInd self.population = Population(nrInd) self.probability_mutate = 0.5 self.probability_crossover = 0.5 def run(self): global ITER self.loadData() self.population.evaluate(self.inputTrain, self.outputTrain) for i in range(ITER): print("Iteration: " + str(i)) self.iteration(i) self.population.evaluate(self.inputTrain, self.outputTrain) self.population.selection(self.nrInd) best = self.population.best(1)[0] print("Best: " + str(best.root) + "\n" + "fitness: " + str(best.fitness)) def loadData(self): global TrainSIZE, HEADER print("Loading training data ... this may take a while") with open(self.filename, "r") as f: HEADER = f.readline().split(',')[1:-1] for line in f.readlines()[:10]: values = list(map(float, line.split(','))) self.input.append(values[1:-1]) self.output.append(values[-1]) self.n += 1 shuffle(self.input) shuffle(self.output) self.inputTrain = self.input[:int(self.n * TrainSIZE)] self.outputTrain = self.output[:int(self.n * TrainSIZE)] self.inputTest = self.input[int(self.n * TrainSIZE):] self.outputTest = self.output[int(self.n * TrainSIZE):] print("Training size: " + str(len(self.inputTrain))) print("Testing size: " + str(len(self.outputTest))) def iteration(self, i): parents = range(self.nrInd) nrChildren = len(parents) // 2 offspring = Population(nrChildren) for i in range(nrChildren): offspring.individuals[i] = Chromosome.crossover( self.population.individuals[i << 1], self.population.individuals[(i << 1) | 1], self.probability_crossover) offspring.individuals[i].mutate(self.probability_mutate) offspring.evaluate(self.inputTrain, self.outputTrain) self.population.reunion(offspring) self.population.selection(self.nrInd)
def test_get_number_immune(): p1_pop = Population("New York", 20, p_virus, 1, 0.5) assert p1_pop.get_number_immune() is 10 p1_pop = Population("New York", 20, p_virus, 1, 1.0) assert p1_pop.get_number_immune() is 20
class UI: def printMenu(self): print("0. Exit") print("1. Use EA") print("2. Use HillClimbing") print("3. Show EA's validation test") print("4. Use PSO") print("5. Show PSO's validation test") def __init__(self): self._population = Population(2,2) self._ea = EA(2) self._hc = HillClimbing(2) self._particles=ParticlePopulation(2,2) self._pso=PSO(self._particles) self._controller = Controller(self._population,self._ea,0,0,self._hc, self._particles.populationGenerate,self._pso) def readData(self): f = open("inputData.txt") x=f.readline().split() n=int(x[0]) k=int(x[1]) noIt=int(x[2]) w=float(x[3]) c1= float(x[4]) c2= float(x[5]) nSize=int(x[6]) f.close() self._population.setSize(n,k) self._ea.setSize(n) self._hc.setSize(n) self._particles.setData(n,k) self._pso=PSO(self._particles) self._controller.setData(noIt,k) return (w,c1,c2,nSize) def runEA(self): (x,pop) = self._controller.iteration() for l in pop: print(l) def runHC(self): ind= self._controller.iterationHC() for l in ind: print(l) def validationEA(self): ''' displays a graphical evaluation of the EA algorithm ''' pop=[] avg=[] std=[] n=self._population._n for i in range(0,30): pop.append([]) self._population= Population(n,40) self._controller= Controller(self._population,self._ea,1000,40,self._hc,self._particles,self._pso) for j in range (0,10): (ind,x)=self._controller.iteration() for k in ind: pop[i].append(self._population.fitness(k)) std.append(np.std(pop[i])) avg.append(np.mean(pop[i])) std =plt.plot(std,color='b',label='Standard deviation') avg =plt.plot(avg,color='r',label='Average') #plt.legend(handles[std,avg]) plt.show() def runPSO(self,w,c1,c2,nSize): pop=self._controller.iterationPSO(w,c1,c2,nSize) best=pop[0] for i in pop: if i.bestFit<best.bestFit: best=i for l in best: print(l) def run(self): (w,c1,c2,nSize)=self.readData() while True: self.printMenu() opt = input("Choose an option: ") if opt == "1": self.runEA() elif opt == "2": self.runHC() elif opt == "3": self.validationEA() elif opt == "4": self.runPSO(w,c1,c2,nSize) elif opt == "0": return
class TestPopulation(TC): def setUp(self): self.orgs = [ MockOrganism(1), MockOrganism(2), MockOrganism(3), MockOrganism(4) ] self.pop = Population(self.orgs) def test_init_nogivensize(self): self.assertEqual(self.pop.carrying_capacity, 4) def test_init_givensize(self): population = Population([1, 2, 3, 4], carrying_capacity=5) self.assertEqual(population.carrying_capacity, 5) def test_removal(self): population = Population([1, 2, 3], carrying_capacity=2) population.remove_at_random() self.assertEqual(len(population), 2) def test_leastfit_removal(self): this_pop = Population( [MockOrganism(1), MockOrganism(2), MockOrganism(100)], carrying_capacity=1) this_pop.remove_least_fit() self.assertIn(this_pop[0].eval_fit(), [1, 2, 100]) self.assertEqual(len(this_pop), 1) def test_replicate(self): self.pop.replicate() self.assertEqual(8, len(self.pop)) def test_advance(self): big_pop = Population( [MockOrganism(1), MockOrganism(2), MockOrganism(90)], 3) big_pop.advance_generation() self.assertLessEqual(len(big_pop), 3) def test_iter_len(self): self.assertEqual(4, len(self.pop)) for org, poporg in zip(self.orgs, self.pop): self.assertEqual(org, poporg) def test_add_to_pop(self): org = MockOrganism(6) self.pop.add_to_pop(org) self.assertEqual(5, len(self.pop)) def test_set(self): self.pop[2] = MockOrganism(6) print self.pop[2] self.assertEqual(self.pop[2].eval_fit(), MockOrganism(6).eval_fit()) def test_full(self): self.assertTrue(self.pop.is_full()) def test_max_fit(self): self.assertEqual(self.pop.max_fitness(), MockOrganism(4).eval_fit()) def test_mean_fit(self): self.assertEqual(self.pop.mean_fitness(), 2.5)
class Game: def __init__(self): pygame.init() pygame.font.init() self.font = pygame.font.SysFont(pygame.font.get_default_font(), 20) self.screen = pygame.display.set_mode((500, 850)) self.clock = pygame.time.Clock() self.fps = 60 self.best = 0 self.x = 0 self.iteration = 1 self.running = False self.all_sprites = pygame.sprite.Group() self.bottom_blocks = pygame.sprite.Group() self.blocks = pygame.sprite.Group() self.birds = pygame.sprite.Group() self.bg = pygame.transform.scale2x(pygame.image.load(os.path.join("sprites/bg.png"))) self.population = Population(self, 50) self.population.init_population() def handle_events(self): for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() def get_next_bottom_block_data(self): next_block = None next_block_id = 0 for block in self.bottom_blocks: if 100 < block.rect.x: next_block = block break return {'x': next_block.rect.x, 'y': next_block.rect.y} def remove_unused_blocks(self): for block in self.blocks: if block.rect.x <= -60: block.kill() def generate_block(self): h = random.randint(250, 500) block_top = Block(Block.TYPE_TOP, 700, h) block_bottom = Block(Block.TYPE_BOTTOM, 700, h) self.all_sprites.add(block_top) self.all_sprites.add(block_bottom) self.blocks.add(block_top) self.bottom_blocks.add(block_bottom) self.blocks.add(block_bottom) def update(self): for bird in self.birds: bird.update_sprite(self.screen) if not bird.is_killed: if pygame.sprite.spritecollide(bird, self.blocks, False): bird.killed(self.x) elif bird.rect.y < -100 or 750 < bird.rect.y: bird.killed(self.x) if self.population.get_alive_count() == 0: self.reset() return if self.x % 100 == 0: self.generate_block() self.x += 1 self.remove_unused_blocks() self.all_sprites.update() def reset(self): self.x = 0 self.birds.empty() self.blocks.empty() self.bottom_blocks.empty() self.all_sprites.empty() self.population.over() self.iteration += 1 def redraw(self): self.screen.blit(self.bg, (0, 0)) self.all_sprites.draw(self.screen) textsurface = self.font.render('Iteration: ' + str(self.iteration) + ' Current: ' + str(self.x) + ' Alive birds: ' + str(self.population.get_alive_count()) + ' Best result: ' + str(self.best), True, (255, 255, 255)) self.screen.blit(textsurface, (0, 0)) def run(self): base = Base(750) while True: self.handle_events() self.update() self.redraw() base.draw(self.screen) base.move() pygame.display.flip() self.clock.tick_busy_loop(self.fps)
class Game(object): ''' Class containing whole snake game. ''' def __init__(self, window_y, window_x, population_size, mutation_rate, crossover_rate): self.screen_size = (window_y, window_x) #self-explanatory self.level = 0 #making gameboard (dummy for now) self.morsel = Apple(self.screen_size) #making apple self.population = Population( #snake family population_size=population_size, mutation_rate=mutation_rate, crossover_rate=crossover_rate, screen=self.screen_size) self.population.first_generation() #cpus snakes self.pressed_key = 0 #dummy for exiting def game(self, stdscr): ''' Actual game''' self.level = GameBoard(self.screen_size) #making gameboard #game loop while self.pressed_key != ord('q'): #main while loop #PLAYER CONTROL SECTION self.pressed_key = self.level.board.getch( ) #getting key from player #CPUs SECTIONS for cpu in self.population.cpus: self.level.unprint(cpu) #erasing all snakes cpu.move(self.morsel) #generating moves if cpu.collides(): #collision checking self.population.cpus.remove(cpu) self.level.unprint(cpu) if cpu.eats(self.morsel): #snake eats an apple pass #temporarly disabled if cpu.starved(): #if snake dies of self.population.cpus.remove(cpu) #starvation self.level.unprint(cpu) #it need to be killed #IS FUN OVER? if self.population.empty(): #checking if board has its winner self.level.unprint(self.population.cpus[0]) self.population.new_generation() #winner is having a child #SCREEN SECTION #printing everything out for cpu in self.population.cpus: #printing every snake self.level.inprint(cpu) self.level.board.border() self.level.print_aux( self.morsel, #print nesseceties self.population.generation) self.level.board.refresh() #refreshing the screen def main(self): curses.wrapper(self.game)
def init_population(dic, puzzles, size=100, inhabitant_start_size=5): return Population(puzzles, size, inhabitant_start_size)
def run(self): self.problem_class.pre_run_hook() population = Population( self.args.population_size, self.problem_class, self.genotype_class, self.individual_class, self.args.adult_selection_method, self.args.parent_selection_method, self.args.adult_pool_size, self.args.crossover_rate, self.args.mutation_rate) for generation in range(self.args.num_generations): if not self.args.silent: print '---------' print 'generation', generation population.set_generation(generation) population.generate_phenotypes() population.evaluate_all() if self.args.stop_early and population.is_solution_found: print 'A solution has been found in generation {}:'.format( generation) print population.solution break population.adult_selection_handler.select_adults() population.log_stats(self.args.silent) population.parent_selection_handler.select_parents() population.reproduce() self.problem_class.post_run_hook(population) return population
def nextGeneration(self, population, data, dataEvaluation, heuristicStrategy, attributeCount): nextGen = Population(1 + (population.size() * 2), data, dataEvaluation, False, heuristicStrategy) nextGen.saveIndividuals(0, population.getFittest()) count = 1 for index in range(population.size()): challenger = self.tournament(population, data, dataEvaluation, heuristicStrategy, attributeCount) champion = self.tournament(population, data, dataEvaluation, heuristicStrategy, attributeCount) nextGenChallenger, nextGenChamp = self.crossover( challenger, champion, int(np.floor(challenger.size() / 2)), heuristicStrategy) nextGen.saveIndividuals(count, nextGenChamp) nextGen.saveIndividuals(count + 1, nextGenChallenger) count += 2 for index in range(nextGen.size()): neo = self.xmen(nextGen.getIndividual(index)) nextGen.saveIndividuals(index, neo) return nextGen
capsize=5, label='{0}nW, n~5000'.format(d2['power'].unique()[0])) # plt.errorbar(Population().rhosum(d2[xvar],P),d2[yvar],yerr=d2[yvar]*d2['g_std'], fmt='o', capsize=5, label='{0}nW, n~5000'.format(d2['power'].unique()[0])) # plt.semilogy(1/(d2[xvar]**2+Omega**2),d2[yvar], linestyle='', marker='^', label='{0}nW, n~5000'.format(d1['power'].unique()[0])) if 'd3' in dir(): plt.errorbar(d3[xvar], d3[yvar], yerr=d3[yvar] * d3['g_std'], fmt='o', capsize=5, label='{0}nW, n~9000'.format(d3['power'].unique()[0])) # plt.errorbar(Population().rhosum(d3[xvar],P),d3[yvar],yerr=d3[yvar]*d3['g_std'], fmt='o', capsize=5, label='{0}nW, n~9000'.format(d3['power'].unique()[0])) # plt.semilogy(1/(d3[xvar]**2+Omega**2),d3[yvar], linestyle='', marker='*', label='{0}nW, n~9000'.format(d1['power'].unique()[0])) plt.plot(xp, fitParams[0] * Population().rhosum(xp, P) + fitParams[1]) print("slope = {0:.3f}".format(fitParams[0])) print("intercept = {0:.3f}".format(fitParams[1])) plt.legend(fontsize=16) #plt.ylim(0,1.2*max(d2[yvar])) plt.xlabel('detuning (GHz)', fontsize=18) #plt.xlabel('$\sum _{F\'=3,4,5} \ \dfrac{\Omega_{F\'}^{2}}{4 \Delta_{F\'}^{2} + 2 \Omega_{F\'}^{2}}$', fontsize=16) plt.ylabel('$\Gamma_R$/2$\pi$ (kHz)', fontsize=18) plt.xticks(fontsize=18) plt.yticks(fontsize=18) #ax.text(3500,8,'Slope = 17.85kHz/$\mu$W', fontsize=16) plt.tight_layout() plt.savefig('gamma_detuning.svg') #plt.show()
def test_removal(self): population = Population([1, 2, 3], carrying_capacity=2) population.remove_at_random() self.assertEqual(len(population), 2)
def test_init_givensize(self): population = Population([1, 2, 3, 4], carrying_capacity=5) self.assertEqual(population.carrying_capacity, 5)
def fitFunc(x, a, b): return a * Population().rhosum(x, P) + b
import sys # from logger import logger # TEST PATHOGEN def test_print_pathogen_info(): ebola = Pathogen("ebola", 0.70, 0.25) ebola_greeting = ebola.print_info(False) assert "ebola" in ebola_greeting assert "70" in ebola_greeting assert "25" in ebola_greeting virus = Pathogen("the black plague", 0.5, 0.5) my_pop = Population("1437 France", 30, virus, 3, 0.5) def clear_log_file(): file = open("NO_FILE_SPECIFIED.md", "w+") file.write("# this file for testing") print("File cleared.") print(file.read()) def read_log_file(): file = open("NO_FILE_SPECIFIED.md", "r") print("File read.") return file.read()
sim_root = '/home/danielk/IRF/E3D_PA/FP_sims/T_UHF_MicrosatR_v2' #initialize the radar setup radar = rlib.eiscat_uhf() radar.set_FOV(max_on_axis=25.0, horizon_elevation=50.0) radar.set_SNR_limits(min_total_SNRdb=14.0, min_pair_SNRdb=14.0) radar.set_scan(scan) fname = sim_root + '/population_{}.h5'.format(branch_name) catname = sim_root + '/' + branch_name + '/catalogue_data.h5' pop = Population.load( fname, propagator=_prop, propagator_options=_opts, ) cat = Catalogue.from_file(pop, catname) time_step = 80.0 #time_step = 600.0 t_end = (mjd - event_mjd + SIM_TIME / 24.0) * 3600.0 * 24.0 t_meas = (mjd - event_mjd) * 3600.0 * 24.0 #_deb_tt = np.arange(0, 3600.0*12.0, time_step, dtype=np.float64) _deb_tt = np.arange(0, 3600.0 * 6.0, time_step, dtype=np.float64) #_mes_tt = np.arange(t_meas, t_end, time_step, dtype=np.float64) #tt = np.append( # _deb_tt,
class RootWindow(object): def __init__(self): self.win = tk.Tk() self.configWin() self.spawnTarget() self.spawnObst() self.pop = Population(100, self.canv, self.targetPos, self.obstPos) self.LIFESPAN = DNA().LIFESPAN self.cnt = 0 self.win.mainloop() def configWin(self): col = '#%02x%02x%02x' % (51, 51, 51) self.fps = int(1000 / 60) self.canv = tk.Canvas(self.win, width=800, height=400, background=col) self.canv.pack() self.win.after(self.fps, self.update) def update(self): # DO ALL THE STUFF HERE self.pop.run(self.cnt) self.cnt += 1 if (self.cnt == self.LIFESPAN): self.pop.evaluate() self.pop.selection() self.cnt = 0 self.canv.update() self.win.after(self.fps, self.update) def spawnObst(self): l = ([300, 200], [500, 200], [600, 50], [600, 350]) self.obstPos = np.array(l) for p in l: x0 = p[0] - 20 x1 = p[0] + 20 if (p[0] == 500): y0 = p[1] - 50 y1 = p[1] + 50 else: y0 = p[1] - 100 y1 = p[1] + 100 self.obstID = self.canv.create_rectangle(x0, y0, x1, y1, fill="red", outline="red") def spawnTarget(self): self.targetPos = np.array([750, 200]) x0 = self.targetPos[0] - 10 x1 = self.targetPos[0] + 10 y0 = self.targetPos[1] - 10 y1 = self.targetPos[1] + 10 self.targetId = self.canv.create_oval(x0, y0, x1, y1, fill="green", outline="green")
def main(): """Parse option""" if len(sys.argv) != 1: #Evaluate a single genome if str(sys.argv[1]) == "-evaluate": initPygame("FlapAI: Evaluating") print(str(sys.argv[2])) net = load(str(sys.argv[2])) genome = Genome(net) global savestat savestat = False fitness = [] for i in range(100): fit = playGame(genome) fitness.append(fit.fitness) print("fitness : %s " % fit.fitness) average = sum(fitness) / float(len(fitness)) printc("Average fitness : %s" % average, "red") pygame.quit() sys.exit() #Show the stat of an experiment if str(sys.argv[1]) == "-stats": showStat(str(sys.argv[2])) #No argument, starting FlapAI initPygame("FlapAI: Learning") """Init the population""" global bestFitness bestFitness = 0 population = Population() population.generateRandomPopulation() generation = 1 maxgeneration = Config.maxGeneration lastgenerationaveragefitness = 0 #Main Loop while generation <= maxgeneration: birdnmbr = 1 for i in range(population.size()): genome = playGame(population.getGenome(i)) population.setGenomeFitness(i, genome.fitness) informationforscreen = { 'generation': generation, 'birdnumber': birdnmbr, 'lastfitness': genome.fitness, 'lastgenerationaveragefitness': lastgenerationaveragefitness, 'bestfitness': bestFitness } updateScreen(informationforscreen) if genome.fitness > bestFitness: #global bestFitness bestFitness = genome.fitness genome.network.save(today + "/bestfitness.json") birdnmbr += 1 global fitnessovergeneration fitnessovergeneration.append(population.averageFitness()) lastgenerationaveragefitness = population.averageFitness() global fittestovergeneration fittestovergeneration.append(population.findFittest().fitness) #Evolve the population population.evolvePopulation() generation += 1
def __init__(self, window, cities_list, show_window=True): if show_window: self.ini = window.figure.add_subplot(211) self.end = window.figure.add_subplot(212) self._cities_list = cities_list random.seed() pop = Population(1000, True, self._cities_list) if show_window: self.plt_reload(211, self._cities_list, 'Starting') print 'Initial distance: %.4f' % (pop.get_fittest().get_distance()) self.x_graph.append(0) self.y_graph.append(pop.get_fittest().get_distance()) for j in xrange(100): new_population = Population(pop.population_size(), False) elitism_offset = 0 if self._elitism: new_population.save_tour(0, pop.get_fittest()) elitism_offset = 1 for i in xrange(elitism_offset, new_population.population_size()): parent1 = self.tournament_selection(pop) parent2 = self.tournament_selection(pop) # Crossover parents child = self.crossover(parent1, parent2) new_population.save_tour(i, child) # mutate for i in xrange(elitism_offset, new_population.population_size()): self.mutate(new_population.get_tour(i)) pop = new_population if show_window: self.plt_reload(212, pop.get_fittest().get_tour(), 'Iteration: ' + str(j + 1)) self.x_graph.append(self.x_graph[-1] + 1) self.y_graph.append(pop.get_fittest().get_distance()) if show_window: self.plt_reload(212, pop.get_fittest().get_tour(), 'Iteration: ' + str(j + 1)) self.x_graph.append(self.x_graph[-1] + 1) self.y_graph.append(pop.get_fittest().get_distance()) print 'Final distance: %.4f' % (pop.get_fittest().get_distance()) self.best_distance = pop.get_fittest().get_distance()
if population.population[i][j].is_dead: canvas.create_rectangle(x, y, x+square_dimension, y+square_dimension, fill='red') else: if population.population[i][j].is_infected: canvas.create_rectangle(x, y, x+square_dimension, y+square_dimension, fill='yellow') else: canvas.create_rectangle(x, y, x+square_dimension, y+square_dimension, fill='green') sim = Simulation() WINDOW_WIDTH = 600 WINDOW_HEIGHT = 600 sim_window = tkinter.Tk() sim_window.title("Epidemic Outbreak") sim_canvas = tkinter.Canvas(sim_window, width=WINDOW_WIDTH, height=WINDOW_HEIGHT, bg='lightblue') sim_canvas.pack(side=tkinter.LEFT) pop = Population(sim) pop.initial_infection(sim) pop.display_statistics(sim) input("Press Enter to begin simulation.") for i in range(1, sim.sim_days): pop.spread_infection(sim) pop.update(sim) pop.display_statistics(sim) graphics(sim, pop, sim_canvas) sim_window.update() if i != sim.sim_days-1: sim_canvas.delete('all')
def __init__(self, dataset, n_iter, pop_size, batch_size, epochs, min_layer, max_layer, \ conv_prob, pool_prob, fc_prob, max_conv_kernel, max_out_ch, max_fc_neurons, dropout_rate): self.pop_size = pop_size self.n_iter = n_iter self.epochs = epochs self.batch_size = batch_size self.gBest_acc = np.zeros(n_iter) self.gBest_test_acc = np.zeros(n_iter) if dataset == "mnist": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 (self.x_train, self.y_train), (self.x_test, self.y_test) = mnist.load_data() if dataset == "fashion-mnist": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 (self.x_train, self.y_train), (self.x_test, self.y_test) = fashion_mnist.load_data() self.x_train = self.x_train.astype('float32') self.x_test = self.x_test.astype('float32') self.x_train /= 255 self.x_test /= 255 if dataset == "mnist-background-images": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 train = np.loadtxt("./datasets/mnist-background-images/mnist_background_images_train.amat") test = np.loadtxt("./datasets/mnist-background-images/mnist_background_images_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "mnist-rotated-digits": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 train = np.loadtxt("./datasets/mnist-rotated-digits/mnist_all_rotation_normalized_float_train_valid.amat") test = np.loadtxt("./datasets/mnist-rotated-digits/mnist_all_rotation_normalized_float_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "mnist-random-background": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 train = np.loadtxt("./datasets/mnist-random-background/mnist_background_random_train.amat") test = np.loadtxt("./datasets/mnist-random-background/mnist_background_random_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "mnist-rotated-with-background": input_width = 28 input_height = 28 input_channels = 1 output_dim = 10 train = np.loadtxt("./datasets/mnist-rotated-with-background/mnist_all_background_images_rotation_normalized_train_valid.amat") test = np.loadtxt("./datasets/mnist-rotated-with-background/mnist_all_background_images_rotation_normalized_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "rectangles": input_width = 28 input_height = 28 input_channels = 1 output_dim = 2 train = np.loadtxt("./datasets/rectangles/rectangles_train.amat") test = np.loadtxt("./datasets/rectangles/rectangles_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "rectangles-images": input_width = 28 input_height = 28 input_channels = 1 output_dim = 2 train = np.loadtxt("./datasets/rectangles-images/rectangles_im_train.amat") test = np.loadtxt("./datasets/rectangles-images/rectangles_im_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] if dataset == "convex": input_width = 28 input_height = 28 input_channels = 1 output_dim = 2 train = np.loadtxt("./datasets/convex/convex_train.amat") test = np.loadtxt("./datasets/convex/convex_test.amat") self.x_train = train[:, :-1] self.x_test = test[:, :-1] # Reshape images to 28x28 self.x_train = np.reshape(self.x_train, (-1, 28, 28)) self.x_test = np.reshape(self.x_test, (-1, 28, 28)) self.y_train = train[:, -1] self.y_test = test[:, -1] self.x_train = self.x_train.reshape(self.x_train.shape[0], self.x_train.shape[1], self.x_train.shape[2], input_channels) self.x_test = self.x_test.reshape(self.x_test.shape[0], self.x_test.shape[1], self.x_test.shape[2], input_channels) self.y_train = keras.utils.to_categorical(self.y_train, output_dim) self.y_test = keras.utils.to_categorical(self.y_test, output_dim) print("Initializing population...") self.population = Population(pop_size, min_layer, max_layer, input_width, input_height, input_channels, conv_prob, pool_prob, fc_prob, max_conv_kernel, max_out_ch, max_fc_neurons, output_dim) print("Verifying accuracy of the current gBest...") print(self.population.particle[0]) self.gBest = deepcopy(self.population.particle[0]) self.gBest.model_compile(dropout_rate) hist = self.gBest.model_fit(self.x_train, self.y_train, batch_size=batch_size, epochs=epochs) test_metrics = self.gBest.model.evaluate(x=self.x_test, y=self.y_test, batch_size=batch_size) self.gBest.model_delete() self.gBest_acc[0] = hist.history['accuracy'][-1] self.gBest_test_acc[0] = test_metrics[1] self.population.particle[0].acc = hist.history['accuracy'][-1] self.population.particle[0].pBest.acc = hist.history['accuracy'][-1] print("Current gBest acc: " + str(self.gBest_acc[0]) + "\n") print("Current gBest test acc: " + str(self.gBest_test_acc[0]) + "\n") print("Looking for a new gBest in the population...") for i in range(1, self.pop_size): print('Initialization - Particle: ' + str(i+1)) print(self.population.particle[i]) self.population.particle[i].model_compile(dropout_rate) hist = self.population.particle[i].model_fit(self.x_train, self.y_train, batch_size=batch_size, epochs=epochs) self.population.particle[i].acc = hist.history['accuracy'][-1] self.population.particle[i].pBest.acc = hist.history['accuracy'][-1] if self.population.particle[i].pBest.acc >= self.gBest_acc[0]: print("Found a new gBest.") self.gBest = deepcopy(self.population.particle[i]) self.gBest_acc[0] = self.population.particle[i].pBest.acc print("New gBest acc: " + str(self.gBest_acc[0])) test_metrics = self.gBest.model.evaluate(x=self.x_test, y=self.y_test, batch_size=batch_size) self.gBest_test_acc[0] = test_metrics[1] print("New gBest test acc: " + str(self.gBest_acc[0])) self.population.particle[i].model_delete() self.gBest.model_delete()
# with open('preferences_12.csv') as csv_file: with open(CSV_FILE) as csv_file: readCSV = csv.reader(csv_file, delimiter=',') iter_csv = iter(readCSV) names = next(iter_csv) for name in names: global_names.append(name) # i = 0 # for row in readCSV: # person = Person(i, row) # guest_list.insert(i, person) # i = i + 1 names.pop(0) # gets rid of the '' for index, row in enumerate(iter_csv): if len(row) < 1: continue name = row.pop(0) person = Person(index, names[index], row) if len(person.preferences) > 0: guest_list.insert(index, person) number_tables = math.ceil(number_guests / table_size) print("The number of guests and tables for this simulation is:", len(guest_list), number_tables) population = Population(number_tables, table_size, guest_list) population.evolve_generations( NUMBER_GENERATIONS, False) # True A only, False B runs with Diversity enhancement
ANT_ID = 0 def get_ant_id(): global ANT_ID ANT_ID += 1 return ANT_ID def create_new_ant(): sensing_area = random.randint(1, 10) p_repeat = random.random() p_target = random.random() p_pheromone = random.random() new_ant = Ant(sensing_area, p_repeat, p_target, p_pheromone, get_id = get_ant_id) return new_ant pop = Population(create_new_ant, pop_size=c.POP_SIZE) env = Environment(N=c.GRID_SIZE, foodRemaining=c.FOOD_INITIAL) #fitMatrix = np.zeros((c.NUM_GENS, c.POP_SIZE)) for g in range(c.NUM_GENS): if g==c.NUM_GENS-1: c.VISUALS = True #reset grid before each simulation env.create_grid() data = pop.evaluate(env) fitVec = pop.get_fitness() print('Generation %03d'%g, ['%0.3f'%x for x in fitVec]) #fitMatrix[g] = fitVec pop.selection()
def run(pop, surveyList, nostdout=False, allsurveyfile=False, scint=False, accelsearch=False, jerksearch=False, rratssearch=False): """ Run the surveys and detect the pulsars.""" # print the population if not nostdout: print "Running doSurvey on population..." print pop # loop over the surveys we want to run on the pop file surveyPops = [] for surv in surveyList: s = Survey(surv) s.discoveries = 0 if not nostdout: print "\nRunning survey {0}".format(surv) # create a new population object to store discovered pulsars in survpop = Population() # HERE SHOULD INCLUDE THE PROPERTIES OF THE ORIGINAL POPULATION # counters nsmear = 0 nout = 0 ntf = 0 ndet = 0 nbr = 0 # loop over the pulsars in the population list for psr in pop.population: # pulsar could be dead (evolve!) - continue if so if psr.dead: continue # is the pulsar over the detection threshold? snr = s.SNRcalc(psr, pop, accelsearch, jerksearch, rratssearch) #print snr ###################################################################################### #This section is to add in degradation due to orbital motion of DNS pulsars. #Remove this if doing literally anything else. #Right now this is very ad-hoc and manual. Optimization possible, maybe not worth right now. deg_fac_1102 = { 'PALFA_one_v_older': 0.9997, 'PHSURV': 0.9997, 'HTRU_low_1757': 0.9912, '1534_survey': 0.9999, 'PMSURV': 0.4649 } #This is for 1913+1102 deg_fac_1913 = { 'PALFA_one_v_older': 0.9953, 'PHSURV': 0.9956, 'HTRU_low_1757': 0.9569, '1534_survey': 0.9999, 'PMSURV': 0.7915 } deg_fac_1946 = { 'PALFA_one_v_older': 0.9514, 'PHSURV': 0.9543, 'HTRU_low_1757': 0.6513, '1534_survey': 0.9999, 'PMSURV': 0.2368 } deg_fac_1757 = { 'PALFA_one_v_older': 0.9710, 'PHSURV': 0.9716, 'HTRU_low_1757': 0.9255, '1534_survey': 0.9999, 'PMSURV': 0.5080 } deg_fac_1534 = { 'PALFA_one_v_older': 0.9999, 'PHSURV': 0.9999, 'HTRU_low_1757': 0.9994, '1534_survey': 0.9999, 'PMSURV': 0.7759 } deg_fac_0737A = { 'PALFA_one_v_older': 0.9910, 'PHSURV': 0.9916, 'HTRU_low_1757': 0.8371, '1534_survey': 0.9999, 'PMSURV': 0.2991 } deg_fac_0737B = { 'PALFA_one_v_older': 0.9999, 'PHSURV': 0.9999, 'HTRU_low_1757': 0.9999, '1534_survey': 0.9999, 'PMSURV': 1 } deg_fac_1756 = { 'PALFA_one_v_older': 0.9999, 'PHSURV': 0.9999, 'HTRU_low_1757': 0.9982, '1534_survey': 0.9999, 'PMSURV': 0.5598 } deg_fac_1906 = { 'PALFA_one_v_older': 0.9999, 'PHSURV': 0.9999, 'HTRU_low_1757': 0.9994, '1534_survey': 0.9999, 'PMSURV': 0.7337 } snr = snr * (deg_fac_1906[surv]**2 ) #Please change this for each DNS ###################################################################################### # add scintillation, if required # modifying S/N rather than flux is sensible because then # a pulsar can have same flux but change S/N in repeated surveys if scint: snr = s.scint(psr, snr) if snr > s.SNRlimit: ndet += 1 psr.snr = snr survpop.population.append(psr) # check if the pulsar has been detected in other # surveys if not psr.detected: # if not, set to detected and increment # number of discoveries by the survey psr.detected = True s.discoveries += 1 elif snr == -1.0: nsmear += 1 elif snr == -2.0: nout += 1 elif snr == -3.0: nbr += 1 else: ntf += 1 # report the results if not nostdout: print "Total pulsars in model = {0}".format(len(pop.population)) print "Number detected by survey {0} = {1}".format(surv, ndet) print "Of which are discoveries = {0}".format(s.discoveries) print "Number too faint = {0}".format(ntf) print "Number smeared = {0}".format(nsmear) print "Number out = {0}".format(nout) if rratssearch: print "Number didn't burst = {0}".format(nbr) print "\n" d = Detections(ndet=ndet, ntf=ntf, nsmear=nsmear, nout=nout, nbr=nbr, ndisc=s.discoveries) surveyPops.append([surv, survpop, d]) if allsurveyfile: allsurvpop = Population() allsurvpop.population = [psr for psr in pop.population if psr.detected] surveyPops.append([None, allsurvpop, None]) return surveyPops
alpha = deepcopy(fittest) if cycle % 100 == 0: print('current cycle: ' + str(cycle) + ', current fitness: ' + str(alpha.fitness)) if alpha.fitness == 26: break if ISLAND_CROSSOVER_RATE > randint(0, 100): basic_sample = sample(populations[0].individuals, 5) catastrophe_sample = sample(populations[1].individuals, 5) crowding_sample = sample(populations[2].individuals, 5) populations[0].replace(catastrophe_sample) populations[0].replace(crowding_sample) populations[1].replace(basic_sample) populations[1].replace(crowding_sample) populations[2].replace(basic_sample) populations[2].replace(catastrophe_sample) cycle += 1 print('Fittest individual in history of all islands: ' + str(alpha.fitness) + ' (cycle ' + str(cycle) + ')') population = Population(POPULATION_SIZE) # basic_evolution(population, True) # evolution_by_catastrophe(population, True) # evolution_by_deterministic_crowding(population, True) island_evolution()
def generate(ngen, surveyList=None, pDistType='lnorm', radialDistType='lfl06', radialDistPars=7.5, electronModel='ne2001', pDistPars=[2.7, -0.34], siDistPars=[-1.6, 0.35], lumDistType='lnorm', lumDistPars=[-1.1, 0.9], zscaleType='exp', zscale=0.33, duty_percent=6., scindex=-3.86, gpsArgs=[None, None], doubleSpec=[None, None], nostdout=False, pattern='gaussian', orbits=False): """ Generate a population of pulsars. Keyword args: ngen -- the number of pulsars to generate (or detect) surveyList -- a list of surveys you want to use to try and detect the pulsars pDistType -- the pulsar period distribution model to use (def=lnorm) radialDistType -- radial distribution model electronModel -- mode to use for Galactic electron distribution pDistPars -- parameters to use for period distribution siDistPars -- parameters to use for spectral index distribution lumDistPars -- parameters to use for luminosity distribution radialDistPars -- parameters for radial distribution zscale -- if using exponential z height, set it here (in kpc) scindex -- spectral index of the scattering model gpsArgs -- add GPS-type spectrum sources doubleSpec -- add double-spectrum type sources nostdout -- (bool) switch off stdout """ pop = Population() # check that the distribution types are supported.... if lumDistType not in ['lnorm', 'pow']: print "Unsupported luminosity distribution: {0}".format(lumDistType) #if pDistType not in ['lnorm', 'norm', 'cc97', 'lorimer12']: # print "Unsupported period distribution: {0}".format(pDistType) if pDistType not in ['lnorm', 'norm', 'cc97', 'lorimer12', 'lorimer15']: print "Unsupported period distribution: {0}".format(pDistType) if radialDistType not in [ 'lfl06', 'yk04', 'isotropic', 'slab', 'disk', 'gauss' ]: print "Unsupported radial distribution: {0}".format(radialDistType) # Edited by Shi Dai, 2017/03/22 if electronModel not in ['ne2001', 'lmt85', 'ymw16']: print "Unsupported electron model: {0}".format(electronModel) if pattern not in ['gaussian', 'airy']: print "Unsupported gain pattern: {0}".format(pattern) if duty_percent < 0.: print "Unsupported value of duty cycle: {0}".format(duty_percent) # need to use properties in this class so they're get/set-type props pop.pDistType = pDistType pop.radialDistType = radialDistType pop.electronModel = electronModel pop.lumDistType = lumDistType pop.rsigma = radialDistPars pop.pmean, pop.psigma = pDistPars pop.simean, pop.sisigma = siDistPars pop.gpsFrac, pop.gpsA = gpsArgs pop.brokenFrac, pop.brokenSI = doubleSpec if pop.lumDistType == 'lnorm': pop.lummean, pop.lumsigma = \ lumDistPars[0], lumDistPars[1] else: try: pop.lummin, pop.lummax, pop.lumpow = \ lumDistPars[0], lumDistPars[1], lumDistPars[2] except ValueError: raise PopulateException('Not enough lum distn parameters') pop.zscaleType = zscaleType pop.zscale = zscale # store the dict of arguments inside the model. Could be useful. try: argspec = inspect.getargspec(generate) key_values = [(arg, locals()[arg]) for arg in argspec.args] pop.arguments = {key: value for (key, value) in key_values} except SyntaxError: pass if not nostdout: print "\tGenerating pulsars with parameters:" param_string_list = [] for key, value in key_values: s = ": ".join([key, str(value)]) param_string_list.append(s) # join this list of strings, and print it s = "\n\t\t".join(param_string_list) print "\t\t{0}".format(s) # set up progress bar for fun :) prog = ProgressBar(min_value=0, max_value=ngen, width=65, mode='dynamic') # create survey objects here and put them in a list if surveyList is not None: surveys = [Survey(s, absolute_importpattern) for s in surveyList] # initialise these counters to zero for surv in surveys: surv.ndet = 0 # number detected surv.nout = 0 # number outside survey region surv.nsmear = 0 # number smeared out surv.ntf = 0 # number too faint # surv.gainpat=pattern else: # make an empty list here - makes some code just a little # simpler - can still loop over an empty list (ie zero times) surveys = [] Lorimer15 = np.loadtxt( '/Users/dai02a/Soft/psrpop/PsrPopPy/lib/python/lorimer15') while pop.ndet < ngen: # Declare new pulsar object p = Pulsar() # period, alpha, rho, width distribution calls # Start creating the pulsar! if pop.pDistType == 'lnorm': p.period = dists.drawlnorm(pop.pmean, pop.psigma) elif pop.pDistType == 'norm': p.period = random.gauss(pop.pmean, pop.psigma) elif pop.pDistType == 'cc97': p.period = _cc97() elif pop.pDistType == 'gamma': print "Gamma function not yet supported" sys.exit() elif pop.pDistType == 'lorimer12': p.period = _lorimer2012_msp_periods() elif pop.pDistType == 'lorimer15': #p.period = _lorimer2015_msp_periods() p.period = Lorimer15[pop.ndet] if duty_percent > 0.: # use a simple duty cycle for each pulsar # with a log-normal scatter width = (float(duty_percent) / 100.) * p.period**0.9 width = math.log10(width) width = dists.drawlnorm(width, 0.3) p.width_degree = width * 360. / p.period else: # use the model to caculate if beaming p.alpha = _genAlpha() p.rho, p.width_degree = _genRhoWidth(p) if p.width_degree == 0.0 and p.rho == 0.0: continue # is pulsar beaming at us? If not, move on! p.beaming = _beaming(p) if not p.beaming: continue # Spectral index stuff here # suppose it might be nice to be able to have GPS sources # AND double spectra. But for now I assume only have one or # none of these types. if random.random() > pop.gpsFrac: # This will evaluate true when gpsArgs[0] is NoneType # might have to change in future p.gpsFlag = 0 else: p.gpsFlag = 1 p.gpsA = pop.gpsA if random.random() > pop.brokenFrac: p.brokenFlag = 0 else: p.brokenFlag = 1 p.brokenSI = pop.brokenSI p.spindex = random.gauss(pop.simean, pop.sisigma) # get galactic position # first, Galactic distribution models if pop.radialDistType == 'isotropic': # calculate gl and gb randomly p.gb = math.degrees(math.asin(random.random())) if random.random() < 0.5: p.gb = 0.0 - p.gb p.gl = random.random() * 360.0 # use gl and gb to compute galactic coordinates # pretend the pulsar is at distance of 1kpc # not sure why, ask Dunc! p.galCoords = go.lb_to_xyz(p.gl, p.gb, 1.0) elif pop.radialDistType == 'slab': p.galCoords = go.slabDist() p.gl, p.gb = go.xyz_to_lb(p.galCoords) elif pop.radialDistType == 'disk': p.galCoords = go.diskDist() p.gl, p.gb = go.xyz_to_lb(p.galCoords) else: # we want to use exponential z and a radial dist if pop.radialDistType == 'lfl06': p.r0 = go.lfl06() elif pop.radialDistType == 'yk04': p.r0 = go.ykr() elif pop.radialDistType == 'gauss': # guassian of mean 0 # and stdDev given by parameter (kpc) p.r0 = random.gauss(0., pop.rsigma) # then calc xyz,distance, l and b if pop.zscaleType == 'exp': zheight = go._double_sided_exp(zscale) else: zheight = random.gauss(0., zscale) gx, gy = go.calcXY(p.r0) p.galCoords = gx, gy, zheight p.gl, p.gb = go.xyz_to_lb(p.galCoords) p.dtrue = go.calc_dtrue(p.galCoords) # Edited by Shi Dai, 2017/03/22 # then calc DM using fortran libs #if pop.electronModel == 'ne2001': # p.dm = go.ne2001_dist_to_dm(p.dtrue, p.gl, p.gb) #elif pop.electronModel == 'lmt85': # p.dm = go.lmt85_dist_to_dm(p.dtrue, p.gl, p.gb) #p.scindex = scindex ## then calc scatter time #p.t_scatter = go.scatter_bhat(p.dm, p.scindex) if pop.electronModel == 'ne2001': p.dm = go.ne2001_dist_to_dm(p.dtrue, p.gl, p.gb) p.t_scatter = go.scatter_bhat(p.dm, p.scindex) elif pop.electronModel == 'lmt85': p.dm = go.lmt85_dist_to_dm(p.dtrue, p.gl, p.gb) p.t_scatter = go.scatter_bhat(p.dm, p.scindex) elif pop.electronModel == 'ymw16': p.dm, p.t_scatter = go.ymw16_dist_to_dm(p.dtrue, p.gl, p.gb) p.scindex = scindex # then calc scatter time if pop.lumDistType == 'lnorm': p.lum_1400 = dists.drawlnorm(pop.lummean, pop.lumsigma) else: p.lum_1400 = dists.powerlaw(pop.lummin, pop.lummax, pop.lumpow) # add in orbital parameters if orbits: orbitalparams.test_1802_2124(p) print p.gb, p.gl # if no surveys, just generate ngen pulsars if surveyList is None: calc_delta(p) pop.population.append(p) pop.ndet += 1 if not nostdout: prog.increment_amount() print prog, '\r', sys.stdout.flush() # if surveys are given, check if pulsar detected or not # in ANY of the surveys else: # just a flag to increment if pulsar is detected detect_int = 0 for surv in surveys: # do SNR calculation SNR = surv.SNRcalc(p, pop) if SNR > surv.SNRlimit: # SNR is over threshold # increment the flag # and survey ndetected detect_int += 1 surv.ndet += 1 continue elif SNR == -1: # pulse is smeared out surv.nsmear += 1 continue elif SNR == -2: # pulsar is outside survey region surv.nout += 1 continue else: # pulsar is just too faint surv.ntf += 1 continue # added by Shi Dai, 2017/02/07 #p.snr = SNR # add the pulsar to the population pop.population.append(p) # if detected, increment ndet (for whole population) # and redraw the progress bar if detect_int: pop.ndet += 1 if not nostdout: prog.increment_amount() print prog, '\r', sys.stdout.flush() # print info to stdout if not nostdout: print "\n" print " Total pulsars = {0}".format(len(pop.population)) print " Total detected = {0}".format(pop.ndet) # print " Number not beaming = {0}".format(surv.nnb) for surv in surveys: print "\n Results for survey '{0}'".format(surv.surveyName) print " Number detected = {0}".format(surv.ndet) print " Number too faint = {0}".format(surv.ntf) print " Number smeared = {0}".format(surv.nsmear) print " Number outside survey area = {0}".format(surv.nout) return pop
points = npr.choice(idx, n_random, replace=False) if (crate > npr.random()): for j in points: gene1[j] = gene2[j] child.setGene(gene1) children.append(child) return (children) if __name__ == "__main__": from readDataset import readDataset from individual import Individual from select import Select dataset = readDataset("./dataset/binary.txt") population = Population() for i in range(5): ind = Individual() ind.createGene(dataset, 10) population.addInd(ind) def evaluate(ind): fitness = sum(ind) return (fitness) population.calcFitness(evaluate) population.show() parents = Select.Tournament(population, 5, 3, "max") for ind in parents: ind.show() print("Onepoint")
def generate(ngen, surveyList=None, age_max=1.0E9, pDistPars=[0.3, 0.15], pDistType = 'norm' , # P distirbution for MSPs (Lorimer et al. 2015) bFieldPars=[12.65, 0.55], birthVPars=[0.0, 180.], siDistPars=[-1.6, 0.35], alignModel='orthogonal', lumDistType='fk06', lumDistPars=[-1.5, 0.5], alignTime=None, spinModel='fk06', beamModel='tm98', birthVModel='gaussian', electronModel='ne2001', braking_index=0, zscale=0.05, duty=5., scindex=-3.86, widthModel=None, nodeathline=False, efficiencycut=None, nostdout=False, nospiralarms=False, keepdead=False, dosurveyList = None, makepop=False): pop = Population() # set the parameters in the population object pop.pmean, pop.psigma = pDistPars pop.bmean, pop.bsigma = bFieldPars if lumDistType == 'pow': try: pop.lummin, pop.lummax, pop.lumpow = \ lumDistPars[0], lumDistPars[1], lumDistPars[2] except ValueError: raise EvolveException('Not enough lum distn parameters for "pow"') elif lumDistType == 'fk06': pop.lumPar1, pop.lumPar2 = lumDistPars[0], lumDistPars[1] if len(lumDistPars) == 3: pop.lumPar3 = lumDistPars[2] else: pop.lumPar3 = 0.18 else: pop.lumPar1, pop.lumPar2 = lumDistPars pop.simean, pop.sisigma = siDistPars pop.birthvmean, pop.birthvsigma = birthVPars pop.alignModel = alignModel pop.alignTime = alignTime pop.spinModel = spinModel pop.beamModel = beamModel pop.birthVModel = birthVModel pop.electronModel = electronModel pop.braking_index = braking_index pop.deathline = not nodeathline pop.nospiralarms = nospiralarms pop.zscale = zscale if widthModel == 'kj07': print "\tLoading KJ07 models...." kj_p_vals, kj_pdot_vals, kj_dists = beammodels.load_kj2007_models() print "\tDone\n" if not nostdout: print "\tGenerating evolved pulsars with parameters:" print "\t\tngen = {0}".format(ngen) print "\t\tUsing electron distn model {0}".format( pop.electronModel) print "\n\t\tPeriod mean, sigma = {0}, {1}".format( pop.pmean, pop.psigma) print "\t\tLuminosity mean, sigma = {0}, {1}".format( pop.lummean, pop.lumsigma) print "\t\tSpectral index mean, sigma = {0}, {1}".format( pop.simean, pop.sisigma) print "\t\tGalactic z scale height = {0} kpc".format( pop.zscale) if widthModel is None: print "\t\tWidth {0}% ".format(duty) else: print "\t\tUsing Karastergiou & Johnston beam width model" # set up progress bar for fun :) prog = ProgressBar(min_value=0, max_value=ngen, width=65, mode='dynamic') # create survey objects here and put them in a list if surveyList is not None: surveys = [Survey(s) for s in surveyList] else: # make an empty list here - makes some code just a little # simpler - can still loop over an empty list (ie zero times) surveys = [] # initialise these counters to zero for surv in surveys: surv.ndet = 0 # number detected surv.nout = 0 # number outside survey region surv.nsmear = 0 # number smeared out surv.ntf = 0 # number too faint # create dosurvey objects here and put them in a list if dosurveyList is not None: dosurveys = [Survey(s) for s in dosurveyList] # initialise these counters to zero for surv in dosurveys: surv.ndet = 0 # number detected surv.nout = 0 # number outside survey region surv.nsmear = 0 # number smeared out surv.ntf = 0 # number too faint # surv.gainpat=pattern else: # make an empty list here - makes some code just a little # simpler - can still loop over an empty list (ie zero times) dosurveys = [] # this is the nitty-gritty loop for generating the pulsars ntot = 0 #total number of pulsars generated by the while loop (including dead, and the ones not beaming towards us) n_alive = 0 #total number of pulsars which are alive (beaming + not beaming towards Earth) n_alive_beam = 0 #total number of alive pulsars beaming towards Earth while pop.ndet < ngen: pulsar = Pulsar() # initial age for pulsar pulsar.age = random.random() * age_max # initial period pulsar.p0 = -1. while (pulsar.p0 <= 0.): if(pDistType == 'norm'): pulsar.p0 = random.gauss(pop.pmean, pop.psigma) elif(pDistType == 'drl15'): L_p0 = np.random.lognormal(mean = pop.pmean, sigma = pop.psigma) pulsar.p0 = np.exp(L_p0)/1000 # period in seconds # initial magnetic field (in Gauss) pulsar.bfield_init = 10**random.gauss(pop.bmean, pop.bsigma) # aligment angle alignpulsar(pulsar, pop) # braking index if pop.braking_index == 0: pulsar.braking_index = 2.5 + 0.5 * random.random() else: pulsar.braking_index = float(pop.braking_index) # apply relevant spin down model pulsar.dead = False # pulsar should start alive! if pop.spinModel == 'fk06': spindown_fk06(pulsar) # apply deathline if relevant if pop.deathline: bhattacharya_deathperiod_92(pulsar) elif pop.spinModel == 'tk01': spindown_tk01(pulsar) # apply deathline if relevant if pop.deathline: bhattacharya_deathperiod_92(pulsar) elif pop.spinModel == 'cs06': # contopoulos and spitkovsky spindown_cs06(pulsar, pop) # if period > 10 seconds, just try a new one if pulsar.period > 10000.0 or pulsar.period < 1.5: continue # cut on pdot too - this doesn't help if pulsar.pdot > 1.e-11 or pulsar.pdot < 1.e-21: continue # define pulse width (default = 6% = 18 degrees) if widthModel is None: width = (float(duty)/100.) * pulsar.period**0.9 width = math.log10(width) width = dists.drawlnorm(width, 0.3) elif widthModel == 'kj07': # Karastergiou & Johnston beam model # find closest p, pdot in the kj lists logp = math.log10(pulsar.period) logpdot = math.log10(pulsar.pdot) p_idx = (np.abs(kj_p_vals - logp)).argmin() pd_idx = (np.abs(kj_pdot_vals - logpdot)).argmin() # pick a width from relevant model dist = kj_dists[p_idx][pd_idx][2] width = np.random.choice(dist) """ width = beammodels.kj2007_width(pulsar) no_width = 0 while width == 0.0: no_width+=1 width = beammodels.kj2007_width(pulsar) # if we get to five, then try a new pulsar if no_width == 5: no_width = 0 continue """ else: print "Undefined width model!" sys.exit() # print width # print pulsar.period, width, pulsar.pdot if width == 0.0: # some kj2007 models make many zero-width sources. Skip! continue pulsar.width_degree = 360. * width / pulsar.period # incrementing the total number of physical pulsars generated by # the model after the unphysical ones are removed ntot += 1 # plough on - only if the pulsar isn't dead! if not pulsar.dead or keepdead: n_alive+=1 # is the pulsar beaming? pulsar_beaming(pulsar, pop.beamModel) # if not, then skip onto next pulsar if not pulsar.beaming: continue # position of the pulsar galacticDistribute(pulsar, pop) # birthvelocity birthVelocity(pulsar, pop) # model the xyz velocity go.vxyz(pulsar) # luminosity if lumDistType == 'fk06': luminosity_fk06(pulsar, alpha=pop.lumPar1, beta=pop.lumPar2, gamma=pop.lumPar3) elif lumDistType == 'lnorm': pulsar.lum_1400 = dists.drawlnorm(pop.lumPar1, pop.lumPar2) elif lumDistType == 'pow': pulsar.lum_1400 = dists.powerlaw(pop.lummin, pop.lummax, pop.lumpow) else: # something's wrong! raise EvolveException('Invalid luminosity distn selected') # apply efficiency cutoff if efficiencycut is not None: if pulsar.efficiency() > efficiencycut: pulsar.dead = True if not keepdead: continue # spectral index pulsar.spindex = random.gauss(pop.simean, pop.sisigma) # calculate galactic coords and distance pulsar.gl, pulsar.gb = go.xyz_to_lb(pulsar.galCoords) pulsar.dtrue = go.calc_dtrue(pulsar.galCoords) # then calc DM using fortran libs if pop.electronModel == 'ne2001': pulsar.dm = go.ne2001_dist_to_dm(pulsar.dtrue, pulsar.gl, pulsar.gb) elif pop.electronModel == 'lmt85': pulsar.dm = go.lmt85_dist_to_dm(pulsar.dtrue, pulsar.gl, pulsar.gb) else: raise EvolveException('Invalid electron dist model selected') pulsar.scindex = scindex pulsar.t_scatter = go.scatter_bhat(pulsar.dm, pulsar.scindex) # if surveys are given, check if pulsar detected or not # in ANY of the surveys if surveyList is not None: detect_int = 0 # just a flag if pulsar is detected for surv in surveys: SNR = surv.SNRcalc(pulsar, pop) if SNR > surv.SNRlimit: # SNR is over threshold # increment the flag # and survey ndetected detect_int += 1 surv.ndet += 1 continue elif SNR == -1: # pulse is smeared out surv.nsmear += 1 continue elif SNR == -2: # pulsar is outside survey region surv.nout += 1 continue else: # pulsar is just too faint surv.ntf += 1 continue # if detected, increment ndet (for whole population) # and redraw the progress bar if detect_int: pop.ndet += 1 # update the counter if not nostdout: prog.increment_amount() print prog, '\r', sys.stdout.flush() else: # no survey list, just add the pulsar to population, # and increment number of pulsars pop.ndet += 1 # update the counter if not nostdout: prog.increment_amount() print prog, '\r', sys.stdout.flush() # increment the total number of alive pulsars beaming towards Earth # should be different from n_alive (as the loop was stopped if pulsar # was found to not beam towards Earth) # is incremented only when pulsar was beaming towards us n_alive_beam += 1 # pulsar isn't dead, and makepop True, add the pulsar to population! if makepop == True: pop.population.append(pulsar) # if dosurveys are given, check if pulsar detected or not # in each of the surveys or any of the survey # just a flag to increment if pulsar is detected if dosurveyList is not None: for surv in dosurveys: SNR = surv.SNRcalc(pulsar, pop) if SNR > surv.SNRlimit: # SNR is over threshold # increment survey ndetected surv.ndet += 1 continue elif SNR == -1: # pulse is smeared out surv.nsmear += 1 continue elif SNR == -2: # pulsar is outside survey region surv.nout += 1 continue else: # pulsar is just too faint surv.ntf += 1 continue else: # pulsar is dead. If no survey list, # just increment number of pulsars if surveyList is None: pop.ndet = ntot # update the counter if not nostdout: prog.increment_amount() print prog, '\r', sys.stdout.flush() if not nostdout: print "\n\n" # print " Total pulsars = {0}".format(len(pop.population)) # print " Total detected = {0}".format(pop.ndet) print " Total pulsars generated = {0}".format(ntot) print " Total living pulsars = {0}".format(n_alive) print " Total living pulsars beaming towards Earth = {0}".format(n_alive_beam) if surveyList is not None: print " Total detected by all surveys = {0}".format(pop.ndet) for surv in surveys: print "\n Results for survey '{0}'".format(surv.surveyName) print " Number detected = {0}".format(surv.ndet) print " Number too faint = {0}".format(surv.ntf) print " Number smeared = {0}".format(surv.nsmear) print " Number outside survey area = {0}".format(surv.nout) for surv in dosurveys: print "\n Dosurvey Results for survey '{0}'".format(surv.surveyName) print " Number detected = {0}".format(surv.ndet) print " Number too faint = {0}".format(surv.ntf) print " Number smeared = {0}".format(surv.nsmear) print " Number outside survey area = {0}".format(surv.nout) dosurvey_result = [] for surv in dosurveys: dosurvey_result.append([surv.surveyName, surv.ndet, surv.ntf, surv.nsmear, surv.nout]) # save list of arguments into the pop #try: # argspec = inspect.getargspec(generate) # key_values = [(arg, locals()[arg]) for arg in argspec.args] # pop.arguments = {key: value for (key, value) in key_values} #except SyntaxError: # pass return pop, dosurvey_result