def __init__(self, problem, _noParticles=POP_SIZE): self.noParticles = _noParticles self.v = [] for i in range(self.noParticles): x = Particle() x.evaluate(problem) self.v.append(x)
def collision(self): for collision in self.collision_ids: if collision == 'enemy' and not self.bullet_type == 'enemy_bullet': if len(Mediator.PARTICLES) < 25: for i in range(random.randint(3, 6)): Mediator.PARTICLES.append( Particle(self.pos.copy(), self.vel.copy(), 'test')) self.remove() if collision == 'fast_enemy' and not self.bullet_type == 'fast_enemy_bullet': if len(Mediator.PARTICLES) < 25: for i in range(random.randint(3, 5)): Mediator.PARTICLES.append( Particle(self.pos.copy(), self.vel.copy(), 'test')) self.remove() if collision == 'player' and not self.bullet_type == 'player_bullet': if len(Mediator.PARTICLES) < 25: for i in range(random.randint(3, 5)): Mediator.PARTICLES.append( Particle(self.pos.copy(), self.vel.copy(), 'test')) self.remove() self.collision_ids.clear()
def __init__(self, aCostFunction, aNumberOfParticles): super().__init__(aCostFunction); # Save the best particle at each iteration #self.best_solution_set = []; # Add a particle self.current_solution_set.append(Particle(self.objective_function.number_of_dimensions, self.objective_function.boundary_set, aCostFunction, self)) # Keep track of the best particle best_particle_index = 0; # Create the particles while len(self.current_solution_set) < aNumberOfParticles: self.current_solution_set.append(Particle(self.objective_function.number_of_dimensions, self.objective_function.boundary_set, aCostFunction, self)) # The new particle is better # Minimisation if self.current_solution_set[best_particle_index].cost > self.current_solution_set[-1].cost: best_particle_index = len(self.current_solution_set) - 1; # Store the best particle #self.best_solution_set.append(copy.deepcopy(best_particle)) self.best_solution = self.current_solution_set[best_particle_index].copy();
def __init__(self, npart=40, inertia=.5, phi=(2, 2, 2), dimensions=(100, 100), maxvelocity=1, Q=Problem1, inertiaPrime=1): self._inertia = inertia self.phi = phi self.globalBestFitness = 0 self.maxvelocity = 1 self.globalBest = None self.Q = Q self.inertiaPrime = inertiaPrime self.swarm = [] #Create and initialize the swarm for i in range(npart): pos = np.zeros(len(dimensions)) for j in range(len(dimensions)): pos[j] = random.randint(-1 * dimensions[j] / 2, dimensions[j] / 2) particle = Particle(pos, dimensions) fitness = particle.updateFitness(Q) if fitness > self.globalBestFitness or self.globalBestFitness == 0: self.globalBestFitness = fitness self.globalBest = particle.pos self.swarm.append(particle)
def draw(): global particles background(0) if len(particles) == 0: # catch for empty particle list particles.append(Particle(width, height, width / 2, height / 2)) for n in reversed(range(len(particles))): particles[n].display() particles[n].update() particles[n].keep_inside_window() if key_is_pressed: wind = Wind(mouse_x, mouse_y) wind_force = wind.wind_force(particles[n].location) particles[n].applyForce(wind_force) if particles[n].is_dead: particles.pop(n) print(f"Particle {n+1} died") if len(particles) >= 20: particles.pop(0) return if mouse_is_pressed: particles.append(Particle(width, height, 500, 100)) for m in range(len(particles)): particles[m].follow(mouse_x, mouse_y) print(f"there are {len(particles)} particles.") return
def __init__(self): SceneBase.__init__(self) playerimage = pygame.transform.scale(pygame.image.load("Images/player.png"), (30, 30)) # creates the Player character in the location 20, 20 self.player = Player.Player(30, 30, playerimage) blueParticle = pygame.image.load("Images/particle_blue.png") redParticle = pygame.image.load("Images/particle_red.png") # Defines the starting positions of the first two Particles for level 1 of the game self.particle1 = Particle.Particle(100, 100, False, None, redParticle, False) self.particle2 = Particle.Particle(100, 200, True, self.particle1, blueParticle, False) # Particle 2 is entangled to Particle one # Defines the position for the first goal for level 1 of the game self.goal = Goal.Goal(400, 400) # NOTE: Negative numbers in wall declarations ruin collision detection self.leftWall = Wall.Wall(0, 0, 20, 600) self.rightWall = Wall.Wall(780, 0, 20, 600) self.topWall = Wall.Wall(0, 0, 800, 20) self.bottomWall = Wall.Wall(0, 580, 800, 20) self.door = Door.Door(760, 300, 20, 100) self.walls=[self.leftWall,self.rightWall,self.bottomWall,self.topWall] # Defines the objects that the Player character cannot pass through self.entities = [self.player,self.particle1, self.particle2, self.leftWall, self.rightWall, self.topWall, self.bottomWall] self.particles=[self.particle1,self.particle2] self.startTime=int(round(time.time())) pygame.mixer.music.load('A Strange Charm.wav') pygame.mixer.music.play(-1)
def __init__(self, aCostFunction, aNumberOfParticles, initial_guess=None): super().__init__(aCostFunction, initial_guess) # Name of the algorithm self.full_name = "Particle Swarm Optimisation" self.short_name = "PSO" self.number_created_children = 0 # Add initial guess if any if not isinstance(self.initial_guess, NoneType): self.current_solution_set.append( PART.Particle(self.objective_function, self, self.initial_guess)) # Create the swarm while (self.getNumberOfParticles() < aNumberOfParticles): self.current_solution_set.append( PART.Particle(self.objective_function, self, self.objective_function.initialRandomGuess())) # Number of new particles created self.number_created_particles = self.getNumberOfParticles() # Number of new particles moved self.number_moved_particles = 0 # Store the best particle self.best_solution = None self.average_objective_value = None self.saveBestParticle()
def update(self, measurement, measCovariance, measWeight): weights = map(lambda state: Particle.calculateWeight( state, measurement, measCovariance), self.particleSet) #extract weights from particles # normalize weights so they sum to 1 (numpy.random.choice won't work if this isn't true) weightSum = sum(weights) numSampled = int(self.numParticles * measWeight) # weighted sample (measWeight * numParticles) particles newParticleSet = [] if weightSum == 0: #all particle weights are 0 numSampled /= 2 #trust this measurement less rospy.loginfo("weights summed to zero for " + str(measurement)) newMeasCov = [[measCovariance[0][0], measCovariance[0][1]], [measCovariance[1][0], measCovariance[1][1]]] newMeas = [measurement[0], measurement[1]] for i in range(numSampled): #randomly sample particles and replace positions with a sample from the measurement p = self.getRandomParticle(None) [nx, ny] = np.random.multivariate_normal(newMeas, newMeasCov) newParticleSet.append( Particle.Particle(nx, ny, p.t, p.vt, p.vn, p.w, p.at, p.an)) else: weights = map(lambda weight: weight / weightSum, weights) for i in range(numSampled): newParticleSet.append(self.getRandomParticle(weights)) # uniformly randomly sample rest of particles for i in range(self.numParticles - numSampled): newParticleSet.append(self.getRandomParticle(None)) self.particleSet = newParticleSet
class Event(object): a = Particle() b = Particle() time = 0.0 countA = 0 countB = 0 def __init__(self, t, a, b): self.a = a self.b = b self.time = t if not a == None: self.countA = self.a.count() else: self.countA = -1 if not b == None: self.countB = self.b.count() else: self.countB = -1 def compareTo(self, that): that = Event() return self.time - that.time def isValid(self): if (self.a != None) and (self.a.count() != self.countA): return False if (self.b != None) and (self.b.count() != self.countB): return False return True
def twobodyparticledecay(self,particle,products): # takes a list of two particles and decays them. ''' Get Produced hadron masses ''' Decaytables = Decaydictionary.Decays() particle4vector = particle.Getvector4D() product1code = products[0] product2code = products[1] mass1 = Decaytables.Getmass(product1code) mass2 = Decaytables.Getmass(product2code) ''' Get boost class which contains useful boosting functions ''' #print "boost in two body called" boost = Boosts.boost4D(particle4vector) ''' CMF mass of the string (mass of decaying object) ''' cmsvector = boost.GetCMF() Mass = cmsvector[0] mom3 = Mass/2 mom3 *= self.Sqrtlambda1(Mass,mass1,mass2) ''' Do the random angle generation ''' randomphi = random.random() randomtheta = random.uniform(-1,1) phi = 2.*numpy.pi*randomphi sinphi = numpy.sin(phi) cosphi = numpy.cos(phi) theta = numpy.pi*randomtheta sintheta = numpy.sin(theta) costheta = numpy.cos(theta) ''' start setting the 4 vectors of the products ''' mom = Fourvector.vector4D(0.,sintheta*cosphi,sintheta*sinphi,costheta) mom *= mom3 E1 = numpy.sqrt(mass1*mass1+mom3*mom3) E2 = numpy.sqrt(mass2*mass2+mom3*mom3) finalvec1 = Fourvector.vector4D() finalvec1[0] = E1 finalvec1 += mom finalvec2 = Fourvector.vector4D() finalvec2[0] = E2 finalvec2 -= mom ''' Boost back into the lab frame ''' print "Is the crash here" finalvec1 = boost/finalvec1 #hadron finalvec2 = boost/finalvec2 #photon ''' Create the particles and return them in a list ''' finalproduct1 = Particle.particle4D(product1code,finalvec1) finalproduct2 = Particle.particle4D(product2code,finalvec2) return [finalproduct1, finalproduct2]
def plot_simple(self, key_x, key_y, colour='black'): plt.figure() plt.title(self.name) plt.xlabel(key_x) plt.ylabel(key_y) plt.scatter(self.values[:, Particle.what_index(key_x)], self.values[:, Particle.what_index(key_y)], marker='o', color=colour) plt.show()
def CreateObject(): TParticle = Particle.NewParticle(30) Particle.SetSprite(TParticle, "sp009") Particle.SetnDirection(TParticle, 1.0, 1.0, 0.0) Particle.SetCor(TParticle, 0.0, 0.0, -0.1) Particle.SetnColor(TParticle, 1.0, 0.8, 1.0, 1.0) Particle.SetkColor(TParticle, 1.0, 0.0, 0.0, 0.0) Particle.SetSpeed(TParticle, 4, 400, 400) Particle.SetLife(TParticle, 0.6) Particle.Init(TParticle) TempObject = GaoObject.NewGaoObject() GaoObject.SetShipType(TempObject, 3) GaoObject.SetExplosion(TempObject, "sp011", "sp012") GaoObject.SetName(TempObject, "DragonFly") GaoObject.SetModel(TempObject, "Ship1") GaoObject.SetTypeGun(TempObject, 2) GaoObject.SetParticlePos(TempObject, 1, 1, 0, 0) GaoObject.SetParamsHS( TempObject, 30.0, #Shield 30.0, #MaxShield 0.5, #SpeedRShield 10.0, #Health 10.0, #MaxHealth 100.0, #GunEnergy 100.0, #MaxGunEnergy 0.6) #SpeedRGunEnergy GaoObject.SetPFS( TempObject, 14.0, #Max Power 1.0, #Mass 150) #Speed Rotation GaoObject.WriteParticle(TempObject, TParticle) return TempObject
def Fire2(): global fire_list, p #while loop for creating the particles p = 0 while p < 5: fire = Particle() #create the object fire.img_number = random.randint(0,1) #random number for a random image particle fire.x = random.randint(fire2_pos_x,fire2_pos_x + 13) #set the x position of the fire to a random integer between 595 and 608 fire.y = 25 fire.vel_x = random.randint(-1,1)/2 #x velocity of the fire particle. Dividing by 2 to give a float fire.vel_y = random.randint(1,4) #y velocity of the fire particle. fire.size = random.randint(1,30) #random size of the fire particle. fire.opacity = 0.5 fire_list.append(fire) #add the particle to the list p += 1 #increase the control variable by 1 #while loop for drawing the fire particles with their respective velocities for fire in fire_list: fire.y += fire.vel_y #increase the y velocity of the fire particle by vel_y fire.x += fire.vel_x #increase the x velocity of the fire particle by vel_x fire.size -= 0.2 #decrease the size of the fire particle by 0.2 fire.opacity -= 0.01 #decrease the opacity of the fire particle by 0.01 jmss.drawImage(fire_img_list[fire.img_number], x = fire.x, y = fire.y, width = fire.size, height = fire.size, opacity = fire.opacity) #once the fire particle gets above 110, delete it from the list if fire.y > max_fire_y: fire_list.remove(fire)
def input(self): for e in self.entities: e.handleInput() if e.health <= 0: explosion = Particle(None, None, ExplosionGraphics(self.screen, self.explosion)) explosion.rect = e.rect explosion.centerx = e.rect.centerx - 100 self.entities.remove(e) self.particles.append(explosion) for player in self.players: player.renew(self)
def __init__(self, w, h, title): super(mySim, self).__init__(w, h, title) self.particle = [] self.particle2 = [] for i in range(100): self.particle.append(Particle.Particle()) for i in range(100): self.particle2.append(Particle.Particle()) self.initObjects()
def __init__(self, w, h, title): super(mySim, self).__init__(w, h, title) self.steam = [] self.particle = [] for i in range(n): #self.particle.append(Particle.Particle()) self.steam.append(Particle.Particle()) for i in range(nn): self.particle.append(Particle.Particle()) self.teapot = teapot.Teapot() self.initObjects()
def predict(self, a): a = Particle() if a == None: return for i in range(len(self.particles)): dt = a.timeToHit(self.particles[i]) e = Event(self.t + dt, a, self.particles[i]) self.pq.insert(e) e1 = Event(self.t + a.timeToHitVerticalWall(), a, None) e2 = Event(self.t + a.timeToHitHorizontalWall(), None, a) self.pq.insert(e1) self.pq.insert(e2)
def graph(c_l, color_l, key_x, key_y): fig, ax = plt.subplots() ax.set_xlabel(key_x) ax.set_ylabel(key_y) for i, c in enumerate(c_l): ax = plt.scatter(c.values[:, Particle.what_index(key_x)], c.values[:, Particle.what_index(key_y)], marker='o', alpha=0.5, color=color_l[i], label=c.name) ax = plt.legend()
def random_scan(): number_of_points_checked = 0 number_of_points = 100 accepted_points = [] higgs_creator = Particle.ParticleCreator(Higgs.Higgs, "configs/higgs.json") scalar_creator = Particle.ParticleCreator(Scalar.Scalar, "configs/scalar.json") fermion_creator = Particle.ParticleCreator(Fermion.Fermion, "configs/fermion.json") neutrino_creator = Particle.ParticleCreator(NeutrinoCouplings.Neutrino, "configs/neutrino_couplings.json") time_start = time.time() time_last_report = 0 time_report_interval = 5 while len(accepted_points) < number_of_points: time_running = time.time() - time_start if time_running > time_last_report + time_report_interval: time_last_report = time_running print("[{:0.1f}]: Checked: {}({:0.2f}/s), Accepted: {}({:0.2f}/s)".format( time_running, number_of_points_checked, number_of_points_checked/time_running, len(accepted_points), len(accepted_points)/time_running) ) model = ModelSPheno.ModelSPheno( higgs_creator.create(), fermion_creator.create(), scalar_creator.create(), neutrino_creator.create(), calculate_branching_ratios=False, calculate_one_loop_masses=True ) number_of_points_checked += 1 try: model.calculate_dependent_variables() except: continue micromegas = MicroMegas(model.spheno_output_file_path) micromegas.calculate() if random.random() < calculate_likelihood(model): accepted_points.append(model) with open("saved_models/{}.json".format(datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S.%f")), "w") as f: f.write( json.dumps(model, default=lambda object: object.__dict__, sort_keys=True, indent=4) )
def __init__(self, poolSize=128, maxIter=50, phi1=0.5, phi2=0.5): self.poolSize = poolSize self.maxIteration = maxIter self.phi1 = phi1 self.phi2 = phi2 self.PSOList = [] self.bestPSOList = [] self.hasiter = 1 self.bestPSO = Particle.Particle() for _ in range(poolSize): p = Particle.Particle() p.generate() self.PSOList.append(p)
def Rain(): #while loop for creating the particles p = 0 while p < 1: rain = Particle() #create the object rain.img = rain_img #image of the rain particle rain.x = random.randint(0,800) #set the x position of the rain to a random integer between 0 and 800 rain.y = 600 rain.vel_y = random.randint(-15,-10) #y velocity of the rain particle. rain.size = 30 #rain particle size rain.opacity = 1 #rain particle opacity rain_list.append(rain) p += 1 #while loop for drawing the fire particles with their respective velocities for rain in rain_list: rain.y += rain.vel_y #decrease the y velocity of the rain particle by vel_y jmss.drawImage(rain.img, x = rain.x, y = rain.y, width = rain.size, height = rain.size, opacity = rain.opacity) #once the rain particle gets below 0 (below the screen), delete it from the list if rain.y < 0: rain_list.remove(rain)
def resample(self): """resample particles""" ## for resampling, a roulette wheel implementaion used. ## http://ais.informatik.uni-freiburg.de/teaching/ss11/robotics/slides/11-pf-mcl.ppt.pdf resampledparticles = [] index = int(np.random.uniform() * self.noOfParticles) maxW = max(self.weights) beta = 0.0 maxV = 0.0 indexOfMaxV = 0 for i in range(self.noOfParticles - 1): if (i % 8) == 0: index2 = int(np.random.uniform() * self.noOfParticles) resampledparticles.append( Particle.Particle(random.random() * self.maze.dimX, random.random() * self.maze.dimY, random.random() * math.pi * 2)) resampledparticles[i].set_noise(5.0, 1.0, 1.0) else: beta = beta + np.random.uniform() * 2 * maxW while self.particles[index].weight < beta: beta = beta - self.particles[index].weight index = (index + 1) % self.noOfParticles resampledparticles.append( Particle.Particle(self.particles[index].x, self.particles[index].y, self.particles[index].orientation)) resampledparticles[i].set_noise(5.0, 1.0, 1.0) #if(self.particles[index].weight>maxW): #maxW = self.particles[index].weight #indexOfMaxV = i '''get the best particle''' tempW = 0 for i in range(self.noOfParticles): if (self.particles[i].weight > tempW): tempW = self.particles[i].weight indexOfMaxV = i bestParticle = Particle.Particle( self.particles[indexOfMaxV].x, self.particles[indexOfMaxV].y, self.particles[indexOfMaxV].orientation) bestParticle.set_noise(5.0, 1.0, 1.0) resampledparticles.append(bestParticle) self.bestParticle = bestParticle for p in resampledparticles: p.add_noise(self.maze.dimX, self.maze.dimY) self.particles = [] self.particles = resampledparticles
def masslessmomenta(lop): noparts = len(lop) newlist = [] for i in range(noparts): if lop[i].Checkgluon() == False: # not a gluon is a quark ''' do momenta boosting things here ''' mass = lop[i].Getinvariantmass() #print mass, "mass in invariant mass" vec = copy.deepcopy(lop[i].Getvector()) #print vec, "vec before" p_2 = 0 for j in range(1,4): # just go over the momentum values, try my scaling formula p_2 += (vec[j]*vec[j]) al = numpy.sqrt((mass*mass + p_2) / p_2) newvector = Fourvector.vector4D(vec[0], al*vec[1],al*vec[2],al*vec[3]) ID = lop[i].GetID() #print ID, "id of theparticle " newparticle = Particle.particle4D(ID,newvector) newlist.append(newparticle) #print newparticle.Getinvariantmass(), "check inv mass" if lop[i].Checkgluon() == True: newlist.append(lop[i]) return newlist
def calcPSOReducer(): index = 1 #bestSwarm = pso.Particle("0;0;0;0;0;0;0;10000000000000;0;0;0"); PSOLogger.info("calcPSO reducer method is started...") swarmArray = [] for line in sys.stdin: line = line.replace("1\t", "") PSOLogger.info("===>line is\n%s" % (line)) swarm = pso.Particle(line) if index == 1: bestSwarm = swarm index = 0 PSOLogger.info("swarm.persBestVal = %s and bestSwarm.persBestVal=%s" % (swarm.persBestVal, bestSwarm.persBestVal)) if swarm.persBestVal < bestSwarm.persBestVal: bestSwarm = swarm #swarm.globalBestPos = bestSwarm.particlePosition #swarm.globalBestVal = bestSwarm.fitness swarmArray.append(swarm) ''' swarm.updatePos(); swarm.fitnessEval(mapper.fitnessFunc); swarm.updateVelocity(); print swarm.strRepr() ''' for newSwarm in swarmArray: newSwarm.globalBestPos = bestSwarm.particlePosition newSwarm.globalBestVal = bestSwarm.fitness newSwarm.updatePos() newSwarm.fitnessEval(mapper.fitnessFunc) newSwarm.updateVelocity() print newSwarm.strRepr()
def easy_generate_pts(initial_con): '''intial position and intial velocity randomized use analyitical field instead of discrete data npt: number of particles ''' initial_pos = initial_con[0] initial_vel = initial_con[1] norbits = 1 dt = 0.01 data_dump_path = "/Users/a1/downloads" p = pt.particle(initial_pos, initial_vel, dt, dump_size=100000000, data_dump_path=data_dump_path, write_data=False, silent=False, periodic=True) # maybe need to calculate the field once again using the interpolator? Guess not. p.set_boundaries(radius_max=10, z_max=5, z_min=-5) # this is for Spheromak and Harris Sheet p.step(getDoubleHarrisField, int(norbits / dt), getDoubleHarrisELectricField) return p
def pso(num_particles, k, w, c1, c2, max_iter, data, score_funcs=None): swarm = [] # List to hold particles of the swarm global_best = [] # Global best position global_fitness = sys.maxsize # Fitness value of the global best position g_fit = [] # Fitness history of the global best position # Create particle swarm and initialize global best position for i in range(num_particles): # Make a new particle cur_particle = Particle.Particle(k, w, c1, c2, data) swarm.append(cur_particle) # As new particles are created update the global best position particle_fitness = cur_particle.fitness(data) if particle_fitness < global_fitness: global_best = cur_particle.position global_fitness = particle_fitness # Track the global best fitness at each iteration g_fit.append(global_fitness) # Run particle swarm for i in range(max_iter): # Update global fitness if a particle in the swarm has a local fitness that is better for particle in swarm: if particle.fitness_val < global_fitness: global_best = particle.position global_fitness = particle.fitness_val g_fit.append(global_fitness) # Update the position and velocity of the particle for particle in swarm: particle.update_particle(global_best, data) return g_fit
def confined_init_r(pts): confined = [] for pt in pts: if pt.is_out_of_bounds() is False: confined.append(pt) confined_init_x = [] confined_init_y = [] confined_init_z = [] for i in range(len(confined)): new_confined_r = confined[i].get_r() new_confined_init_r = new_confined_r[0] new_confined_init_x = new_confined_init_r[0] new_confined_init_y = new_confined_init_r[1] new_confined_init_z = new_confined_init_r[2] confined_init_x.append(new_confined_init_x) confined_init_y.append(new_confined_init_y) confined_init_z.append(new_confined_init_z) confined_init_x = np.asarray(confined_init_x) confined_init_y = np.asarray(confined_init_y) confined_init_z = np.asarray(confined_init_z) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(confined_init_x, confined_init_y, confined_init_z) ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_zlabel('Z') plt.show()
def init_speed_vs_final_distance(pts): speed_0 = [] dist_f = [] for pt in pts: new_v = pt.get_v() new_r = pt.get_r() dist_f.append(np.sqrt(np.dot(new_r[-1], new_r[-1]))) speed_0.append(np.sqrt(np.dot(new_v[0], new_v[0]))) speed_0, dist_f = np.asarray(speed_0), np.asarray(dist_f) fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(speed_0, dist_f) ax.set_xlabel('init speed') ax.set_ylabel('final distance') ax.set_title('initial speed vs the final distance') plt.show()
def generate_pts_vary(initial_con): initial_pos = initial_con[0] initial_vel = initial_con[1] sigma = initial_con[2] by0 = initial_con[3] norbits = 2 dt = 0.1 data_dump_path = "/Users/a1/downloads" p = pt.particle(initial_pos, initial_vel, dt, dump_size=100000000, data_dump_path=data_dump_path, write_data=False, silent=False, periodic=True, sigma=sigma, by0=by0) # maybe need to calculate the field once again using the interpolator? Guess not. p.set_boundaries(radius_max=10, z_max=5, z_min=-5) # this is for Spheromak and Harris Sheet #p.step(getDoubleHarrisField, int(norbits / dt), getDoubleHarrisELectricField) p.step_only_harris(getDoubleHarrisField, int(norbits / dt), getDoubleHarrisELectricField) return p
def get_max_final_speed(pts): speed_f = [] for pt in pts: new_v = pt.get_v() speed_f.append(np.sqrt(np.dot(new_v[-1], new_v[-1]))) speed_f = np.asarray(speed_f) return np.amax(speed_f)
def avr_final_speed(pts): final_speed = [] for pt in pts: new_v = pt.get_v() final_speed.append(np.sqrt(np.dot(new_v[-1], new_v[-1]))) final_speed = np.asarray(final_speed) return np.average(final_speed)
def resample(self): """ Resampling is done if number of particles drops below a threshold :return: None """ theta = [0, -0.1, 0, 0.1, 0] if self.total_particles - len(self.particles) > (self.total_particles / 2): self.particles.sort(key=lambda x: -x.weight) new = list(self.particles) for j in range(self.total_particles - len(self.particles)): i = j % (len(self.particles)) new.append( Particle( self.particles[i].pose.x + random.uniform(0.1, 0.2), self.particles[i].pose.y + random.uniform(0.1, 0.2), self.particles[i].pose.theta + random.choice(theta), self.particles[i].weight)) self.particles = new else: print('no resampling: ' + str(len(self.particles)))
def __init__(self, npart = 40, inertia=.5, phi = (2, 2, 2), dimensions = (100, 100), maxvelocity=1, Q = Problem1, inertiaPrime = 1): self._inertia = inertia self.phi = phi self.globalBestFitness = 0 self.maxvelocity = 1 self.globalBest = None self.Q = Q self.inertiaPrime = inertiaPrime self.swarm = [] #Create and initialize the swarm for i in range(npart): pos = np.zeros(len(dimensions)) for j in range(len(dimensions)): pos[j] = random.randint(-1 * dimensions[j]/2, dimensions[j]/2) particle = Particle(pos, dimensions) fitness = particle.updateFitness(Q) if fitness > self.globalBestFitness or self.globalBestFitness == 0: self.globalBestFitness = fitness self.globalBest = particle.pos self.swarm.append(particle)
elif opt == '-T': temperature = float(arg) elif opt == '-v': viscosity = float(arg) elif opt == '-x': flow_coefs[0] = float(arg) elif opt == '-y': flow_coefs[1] = float(arg) elif opt == '-z': flow_coefs[2] = float(arg) if ndim < 1 or ndim > 3: print 'Invalid number of dimensions.' sys.exit(1) # Get a track. small_sphere = Particle(ndim, radius, viscosity, temperature) small_sphere.add_bulk_flow(flow_coefs[:ndim], time_step, nsteps) # The flow is computed in get_diffusion when correcting for it. # No need to call get_bulk_flow. small_sphere.get_diffusion(flow=True) # Display some results: print 'Number of dimensions:', ndim print 'Number of steps:', nsteps print 'Radius of particles:', radius, 'um' print 'Viscosity of solution:', viscosity, 'Ps' print 'Temperature of solution:', temperature, 'K' print 'Time step:', time_step, 's' print print 'Theoretical diffusion:', small_sphere.diffusion.theory
def threebodyparticledecay(self,decayingparticle,producthadrons): # product hadrons = list of particles (from chosendecay in hadrondecay module) decayingvector = decayingparticle.Getvector4D() hadron1code = producthadrons[0] hadron2code = producthadrons[1] hadron3code = producthadrons[2] Decaytables = Decaydictionary.Decays() m1 = Decaytables.Getmass(hadron1code) m2 = Decaytables.Getmass(hadron2code) m3 = Decaytables.Getmass(hadron3code) boost = Boosts.boost4D(decayingvector) cmsvector = boost.GetCMF() Mass = cmsvector[0] ''' PLACE HOLDER HERE TO TRY AND GET A RESULT. NOT TOO CONCERNED ABOUT MOMENTA YET ''' finalvec1 = Fourvector.vector4D(m1,0,0,0) finalvec2 = Fourvector.vector4D(m2,0,0,0) finalvec3 = Fourvector.vector4D(m3,0,0,0) product1 = Particle.particle4D(hadron1code,finalvec1) product2 = Particle.particle4D(hadron2code,finalvec2) product3 = Particle.particle4D(hadron3code,finalvec3) return [product1,product2,product3] while True: print "ARE WE STUCK IN THE TIME WARP LOOP. 3 - BODY DECAY" ''' Constrain m12 ''' m12_min = m1 + m2 m12_max = Mass - m3 D_m12 = m12_max - m12_min rng = random.random() m12 = m12_min + rng * D_m12 # select a number randomly (uniform) between m12min and m12max. ''' Use m12 to constrain m23 ''' E2 = (m12*m12 - m1*m1 + m2*m2) / (2*m12) # the energy of particle 2 in the rest frame of m12 E3 = (Mass*Mass - m12*m12 - m3*m3) / (2*m12) # same but for 3 m23_min = (E2 + E3)*(E2 + E3) - (numpy.sqrt(E2*E2 - m2*m2) + numpy.sqrt(E3*E3 - m3*m3))**2 # these two are m23 squared m23_max = (E2 + E3)*(E2 + E3) - (numpy.sqrt(E2*E2 - m2*m2) - numpy.sqrt(E3*E3 - m3*m3))**2 D_m23 = numpy.sqrt(m23_max) - numpy.sqrt(m23_min) rng2 = random.random() m23 = numpy.sqrt(m23_min) + rng2 * D_m23 ''' Calculate m13 from m12, m23 ''' m13_2 = Mass*Mass + m1*m1 + m2+m2 + m3*m3 - m12*m12* - m23*m23 m13 = numpy.sqrt(m13_2) ''' Hardcode the momenta functions ''' # Can use lambda as well to get the expressions p1 = (Mass/2) * self.Sqrtlambda1(Mass,m23,m1) #print p1, "p1" p2 = (Mass/2) * self.Sqrtlambda1(Mass,m13,m2) #print p2, "p2" p3 = (Mass/2) * self.Sqrtlambda1(Mass,m12,m3) #print p3, "p3" ''' Generate the angles phi is isotropic ''' randomphi = random.random() phi = 2.*numpy.pi*randomphi sinphi = numpy.sin(phi) cosphi = numpy.cos(phi) ''' Generate the thetas in the plane of decay ''' # First momentum theta is random. randomtheta1 = random.uniform(-1,1) theta1 = numpy.pi*randomtheta1 sintheta1 = numpy.sin(theta1) costheta1 = numpy.cos(theta1) # Second is also random, and helps determine the second. However have to generate sensible / possible angles for i in range(100): randomtheta2 = random.uniform(-1,1) theta2 = numpy.pi*randomtheta2 sintheta2 = numpy.sin(theta2) costheta2 = numpy.cos(theta2) # Third constrained by the first two in order to balance momentum. sintheta3 = (-p1*sintheta1 - p2*sintheta2) / p3 costheta3 = (-p1*costheta1 - p2*costheta2) / p3 if abs(sintheta3) <= 1 and abs(costheta3) <= 1: ''' Build the 4 vectors ''' vecE1 = numpy.sqrt(m1*m1 + p1*p1) #print vecE1, "vecE1" vecE2 = numpy.sqrt(m2*m2 + p2*p2) #print vecE2, "vecE2" vecE3 = numpy.sqrt(m3*m3 + p3*p3) #print vecE3, "vecE3" finalvec1 = Fourvector.vector4D(vecE1,p1*sintheta1*cosphi,p1*sintheta1*sinphi,costheta1) finalvec1 = boost/finalvec1 finalvec2 = Fourvector.vector4D(vecE2,p2*sintheta2*cosphi,p2*sintheta2*sinphi,costheta2) finalvec2 = boost/finalvec2 finalvec3 = Fourvector.vector4D(vecE3,p3*sintheta3*cosphi,p3*sintheta3*sinphi,costheta3) finalvec3 = boost/finalvec3 ''' Construct the particles ''' product1 = Particle.particle4D(hadron1code,finalvec1) product2 = Particle.particle4D(hadron2code,finalvec2) product3 = Particle.particle4D(hadron3code,finalvec3) return [product1,product2,product3]
particle.w_inertia = .9 * particle.w_inertia Cf = 1.0 / pso_data.Ns for dim in xrange(particle.Ndimensions): minp, maxp = particle.positionMinMaxList[dim] particle.velocityMax[dim] = Cf * (maxp - minp) if pso_data.current_iteration >= pso_data.max_iterations: RETURNVALUE = 2 # Codes seem kinda lame here print "Updating particle velocities and positions." # Update each of the particles with the record of how it's done. for ndx, res in enumerate(pso_data.current_particle_results): pso_data.particle_list[ndx].setFitness( res ) bestparticle = Particle.determineBestParticle(pso_data.particle_list) print "Updated Positions:" for p_ndx, particle in enumerate(pso_data.particle_list): print "Particle %d Pre: \n\tPosition - %s, \n\tVelocity - %s" % (p_ndx, particle.position, particle.velocity) particle.updateVelocity(bestparticle) particle.updatePosition() print "Particle %d Post: \n\tPosition - %s, \n\tVelocity - %s" % (p_ndx, particle.position, particle.velocity) epopt.appendParticlePositionsToDisk( pso_data.OutputFile, pso_data.current_iteration, pso_data.particle_list) pso_data.current_particle_results = [] # # pso is in the correct state, so we prepare a file of results to
elif opt == '-n': nsteps = int(arg) elif opt == '-q': quiet = True elif opt == '-t': time_step = float(arg) elif opt == '-T': temperature = float(arg) elif opt == '-v': viscosity = float(arg) if ndim < 1 or ndim > 3: print 'Invalid number of dimensions.' sys.exit(1) # Get a track. small_sphere = Particle(ndim, radius, viscosity, temperature) small_sphere.generate_motion(nsteps, time_step) # Display some results: small_sphere.get_diffusion() print 'Number of dimensions:', ndim print 'Number of steps:', nsteps print 'Radius of particles:', radius, 'um' print 'Viscosity of solution:', viscosity, 'Ps' print 'Temperature of solution:', temperature, 'K' print 'Time step:', time_step, 's' print print 'Theoretical diffusion:', small_sphere.diffusion.theory print 'Diffusion:', small_sphere.diffusion.data print 'Standard error:', small_sphere.diffusion.std_err
background = pygame.Surface((800, 600)) background.fill(background_color) clock = pygame.time.Clock() menu = Menu() END_MUSIC_EVENT = pygame.USEREVENT + 0 pygame.mixer.music.set_endevent(END_MUSIC_EVENT) sound = pygame.mixer.Sound("background.wav") sound.play() logic = Logic(pygame, screen) ship = Ship(pygame, screen) particle = Particle(pygame, screen,logic,0,0) handler = EventHandler() while clear(): for event in pygame.event.get(): if event.type == QUIT: sys.exit() elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP: handler.handle(event, pygame, screen, ship) elif event.type == END_MUSIC_EVENT and event.code == 0: sound.play() logic.hit_ship() if logic.win_game(): clear() menu.draw_winner(pygame,screen,logic.score)
def init(): Ur.init() AbInitio.init() Particle.init() AttributeGroup.init() GroupInit() FSM.init() lfInit() Element.init() Component.init() List.init() elts.Init.init() validate.veInit() # Could this be computed from the reflectedName property of the types -- does # Python give access to the class hierarchy top-down? psviIndMap.update({'schema':DumpedSchema, 'atomic':(SimpleType,AbInitio.AbInitio), 'list':(SimpleType,List.List), 'union':(SimpleType,Union), 'complexTypeDefinition':ComplexType, 'attributeUse':AttributeUse, 'attributeDeclaration':Attribute, 'particle':Particle.Particle, 'modelGroupDefinition':(Group,ModelGroup), 'modelGroup':Group, 'elementDeclaration':Element.Element, 'wildcard':Wildcard, 'annotation':None, 'enumeration':Enumeration, 'whiteSpace':Whitespace, 'pattern':Pattern, 'maxInclusive':MaxInclusive, 'minInclusive':MinInclusive, 'fractionDigits':FractionDigits, 'precision':Precision, 'lexicalMappings':LexicalMappings, 'attributeGroupDefinition':AttributeGroup.AttributeGroup, 'key':Key, 'keyref':Keyref, 'unique':Unique, 'xpath':xpathTemp}) auxComponentMap.update({'namespaceSchemaInformation':namespaceSchemaInformation, 'valueConstraint':valueConstraint, 'namespaceConstraint':namespaceConstraint, 'contentType':contentType, 'schemaDocument':schemaDocument}) _Nmtoken=("1.0",u'[-.:A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u01f5\u01fa-\u0217\u0250-\u02a8\u02bb-\u02c1\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03d6\u03da\u03dc\u03de\u03e0\u03e2-\u03f3\u0401-\u040c\u040e-\u044f\u0451-\u045c\u045e-\u0481\u0490-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04d0-\u04eb\u04ee-\u04f5\u04f8-\u04f9\u0531-\u0556\u0559\u0561-\u0586\u05d0-\u05ea\u05f0-\u05f2\u0621-\u063a\u0641-\u064a\u0671-\u06b7\u06ba-\u06be\u06c0-\u06ce\u06d0-\u06d3\u06d5\u06e5-\u06e6\u0905-\u0939\u093d\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8b\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ae0\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b36-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cde\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61\u0e01-\u0e2e\u0e30\u0e32-\u0e33\u0e40-\u0e45\u0e81-\u0e82\u0e84\u0e87-\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa-\u0eab\u0ead-\u0eae\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0f40-\u0f47\u0f49-\u0f69\u10a0-\u10c5\u10d0-\u10f6\u1100\u1102-\u1103\u1105-\u1107\u1109\u110b-\u110c\u110e-\u1112\u113c\u113e\u1140\u114c\u114e\u1150\u1154-\u1155\u1159\u115f-\u1161\u1163\u1165\u1167\u1169\u116d-\u116e\u1172-\u1173\u1175\u119e\u11a8\u11ab\u11ae-\u11af\u11b7-\u11b8\u11ba\u11bc-\u11c2\u11eb\u11f0\u11f9\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2126\u212a-\u212b\u212e\u2180-\u2182\u3041-\u3094\u30a1-\u30fa\u3105-\u312c\uac00-\ud7a3\u4e00-\u9fa5\u3007\u3021-\u30290-9\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be7-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u0300-\u0345\u0360-\u0361\u0483-\u0486\u0591-\u05a1\u05a3-\u05b9\u05bb-\u05bd\u05bf\u05c1-\u05c2\u05c4\u064b-\u0652\u0670\u06d6-\u06dc\u06dd-\u06df\u06e0-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0901-\u0903\u093c\u093e-\u094c\u094d\u0951-\u0954\u0962-\u0963\u0981-\u0983\u09bc\u09be\u09bf\u09c0-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u0a02\u0a3c\u0a3e\u0a3f\u0a40-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a70-\u0a71\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0b01-\u0b03\u0b3c\u0b3e-\u0b43\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b82-\u0b83\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c01-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c82-\u0c83\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0d02-\u0d03\u0d3e-\u0d43\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb-\u0ebc\u0ec8-\u0ecd\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86-\u0f8b\u0f90-\u0f95\u0f97\u0f99-\u0fad\u0fb1-\u0fb7\u0fb9\u20d0-\u20dc\u20e1\u302a-\u302f\u3099\u309a\xb7\u02d0\u02d1\u0387\u0640\u0e46\u0ec6\u3005\u3031-\u3035\u309d-\u309e\u30fc-\u30fe]+') _Nmtoken11=("1.1",u'[-.0-9:A-Z_a-z\xb7\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0300-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]+') _Name=("1.0",u'[_:A-Za-z\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u01f5\u01fa-\u0217\u0250-\u02a8\u02bb-\u02c1\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03d6\u03da\u03dc\u03de\u03e0\u03e2-\u03f3\u0401-\u040c\u040e-\u044f\u0451-\u045c\u045e-\u0481\u0490-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04d0-\u04eb\u04ee-\u04f5\u04f8-\u04f9\u0531-\u0556\u0559\u0561-\u0586\u05d0-\u05ea\u05f0-\u05f2\u0621-\u063a\u0641-\u064a\u0671-\u06b7\u06ba-\u06be\u06c0-\u06ce\u06d0-\u06d3\u06d5\u06e5-\u06e6\u0905-\u0939\u093d\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8b\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ae0\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b36-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cde\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61\u0e01-\u0e2e\u0e30\u0e32-\u0e33\u0e40-\u0e45\u0e81-\u0e82\u0e84\u0e87-\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa-\u0eab\u0ead-\u0eae\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0f40-\u0f47\u0f49-\u0f69\u10a0-\u10c5\u10d0-\u10f6\u1100\u1102-\u1103\u1105-\u1107\u1109\u110b-\u110c\u110e-\u1112\u113c\u113e\u1140\u114c\u114e\u1150\u1154-\u1155\u1159\u115f-\u1161\u1163\u1165\u1167\u1169\u116d-\u116e\u1172-\u1173\u1175\u119e\u11a8\u11ab\u11ae-\u11af\u11b7-\u11b8\u11ba\u11bc-\u11c2\u11eb\u11f0\u11f9\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2126\u212a-\u212b\u212e\u2180-\u2182\u3041-\u3094\u30a1-\u30fa\u3105-\u312c\uac00-\ud7a3\u4e00-\u9fa5\u3007\u3021-\u3029][-._:A-Za-z\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u01f5\u01fa-\u0217\u0250-\u02a8\u02bb-\u02c1\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03d6\u03da\u03dc\u03de\u03e0\u03e2-\u03f3\u0401-\u040c\u040e-\u044f\u0451-\u045c\u045e-\u0481\u0490-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04d0-\u04eb\u04ee-\u04f5\u04f8-\u04f9\u0531-\u0556\u0559\u0561-\u0586\u05d0-\u05ea\u05f0-\u05f2\u0621-\u063a\u0641-\u064a\u0671-\u06b7\u06ba-\u06be\u06c0-\u06ce\u06d0-\u06d3\u06d5\u06e5-\u06e6\u0905-\u0939\u093d\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8b\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ae0\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b36-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cde\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61\u0e01-\u0e2e\u0e30\u0e32-\u0e33\u0e40-\u0e45\u0e81-\u0e82\u0e84\u0e87-\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa-\u0eab\u0ead-\u0eae\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0f40-\u0f47\u0f49-\u0f69\u10a0-\u10c5\u10d0-\u10f6\u1100\u1102-\u1103\u1105-\u1107\u1109\u110b-\u110c\u110e-\u1112\u113c\u113e\u1140\u114c\u114e\u1150\u1154-\u1155\u1159\u115f-\u1161\u1163\u1165\u1167\u1169\u116d-\u116e\u1172-\u1173\u1175\u119e\u11a8\u11ab\u11ae-\u11af\u11b7-\u11b8\u11ba\u11bc-\u11c2\u11eb\u11f0\u11f9\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2126\u212a-\u212b\u212e\u2180-\u2182\u3041-\u3094\u30a1-\u30fa\u3105-\u312c\uac00-\ud7a3\u4e00-\u9fa5\u3007\u3021-\u30290-9\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be7-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u0300-\u0345\u0360-\u0361\u0483-\u0486\u0591-\u05a1\u05a3-\u05b9\u05bb-\u05bd\u05bf\u05c1-\u05c2\u05c4\u064b-\u0652\u0670\u06d6-\u06dc\u06dd-\u06df\u06e0-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0901-\u0903\u093c\u093e-\u094c\u094d\u0951-\u0954\u0962-\u0963\u0981-\u0983\u09bc\u09be\u09bf\u09c0-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u0a02\u0a3c\u0a3e\u0a3f\u0a40-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a70-\u0a71\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0b01-\u0b03\u0b3c\u0b3e-\u0b43\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b82-\u0b83\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c01-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c82-\u0c83\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0d02-\u0d03\u0d3e-\u0d43\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb-\u0ebc\u0ec8-\u0ecd\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86-\u0f8b\u0f90-\u0f95\u0f97\u0f99-\u0fad\u0fb1-\u0fb7\u0fb9\u20d0-\u20dc\u20e1\u302a-\u302f\u3099\u309a\xb7\u02d0\u02d1\u0387\u0640\u0e46\u0ec6\u3005\u3031-\u3035\u309d-\u309e\u30fc-\u30fe]*') _Name11=("1.1",u'[:A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0370-\u037d\u037f-\u1fff\u200c-\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd][-.0-9:A-Z_a-z\xb7\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0300-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]*') _language="([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]+)(-[a-zA-Z]{1,8})*" _NCName="[^:]*" builtinPats.extend([_Name,_Name11,_Nmtoken,_Nmtoken11,_language,_NCName]) builtinTypeNames.extend([ ('normalizedString','string',((Whitespace,"replace"),),0), ('token','normalizedString',((Whitespace,"collapse"),),0), ('language','token', ((Pattern,[_language]),),0), ('NMTOKEN','token',((Pattern,[_Nmtoken,_Nmtoken11]),),0), ('Name','token',((Pattern,[_Name,_Name11]),),0), ('NCName','Name',((Pattern,[_NCName]),),0), ('ID','NCName',(),1), ('IDREF','NCName',(),2), ('ENTITY','NCName',(),0), ('aPDecimal','pDecimal',((LexicalMappings,['nodecimal', 'decimal']), (Precision,0)),0), ('integer','decimal',((FractionDigits,0),),0), ('nonPositiveInteger','integer',((MaxInclusive,0),),0), ('negativeInteger','nonPositiveInteger', ((MaxInclusive,-1),),0), ('long','integer',((MinInclusive,-9223372036854775808L), (MaxInclusive,9223372036854775807L)),0), ('int','long',((MinInclusive,-2147483648L),(MaxInclusive,2147483647)),0), ('short','int',((MinInclusive,-32768),(MaxInclusive,32767)),0), ('byte','short',((MinInclusive,-128),(MaxInclusive,127)),0), ('nonNegativeInteger','integer',((MinInclusive,0),),0), ('unsignedLong','nonNegativeInteger',((MaxInclusive,18446744073709551615L),),0), ('unsignedInt','unsignedLong',((MaxInclusive,4294967295L),),0), ('unsignedShort','unsignedInt',((MaxInclusive,65535),),0), ('unsignedByte','unsignedShort',((MaxInclusive,255),),0), ('positiveInteger','nonNegativeInteger',((MinInclusive,1),),0)]) XSV.NCNamePat = re.compile("(%s)$"%_Name[1]); XSV.NCNamePat11 = re.compile("(%s)$"%_Name11[1]);
def Decaystring(self,decayingstring,decayingquarknumber,hadronproducedID): #class that takes an (unboosted) mrs as an arguement and decays it, producing a particle and a new iteration of string. ''' NOTE - DECAYING SIDE ONLY CARES IF THE NUMBER IS POSITIVE OR NEGATIVE - I.E. PDG CODE OF QUARK / ANTIQUARK REPSECTIVELY ''' #print "decaystring class reached" Decaytables = Decaydictionary.Decays() twobodyclass = Twobodydecay.twobodydecay4D() hadroncodetest = PDG_ID.PDG_Type(hadronproducedID) if hadroncodetest.isBaryon() is True: if self.__qPDG.isQuark() or self.__qbarPDG.isQuark() is True: baryonproducts = self.Baryonproduction(hadronproducedID,decayingquarknumber) if baryonproducts[1] == 0: stringcontent = [baryonproducts[0],self.__qbarID] #print stringcontent, "IS THERE SOMETHING WRONG HERE" if baryonproducts[1] == 1: stringcontent = [self.__qID, baryonproducts[0]] #print stringcontent, "HOW ABOUT HERE, IS THERE ERROR" ''' If the produced particle is a diquark i.e. producing diquarks at the ends of the string. just need to redistribute momentum via a two body decay ''' if hadroncodetest.isDiquark() is True: # i.e. we're producing two diquarks, one at each end of the string recievingdiquark = self.Finddiquarkstringcontent(decayingquarknumber,hadronproducedID) #print recievingdiquark, "RECIEVINGDIQUARK" newstring = twobodyclass.Twobodydiquarks(decayingstring,hadronproducedID,recievingdiquark) # produce a new string, hadronproduced ID here is a DIQUARK. adc = Availabledecays.availabledecays4D(newstring)# AVAILABLE DECAY CLASS newproducts = adc.Finddecay() ''' Assign the new values to the parameters in the code. now producing a baryon from a diquark end ''' decayingquarknumber = newproducts[0] #print decayingquarknumber, "DECAYINGQUARK NUMBER IN THE BARYONPROD" hadronproducedID = newproducts[1] #print hadronproducedID, "HADRONPRODUCED ID IN THE BAREEREREREOWIJIW3ERJIOWEJ" #print PDG_ID.PDG_Type.mass(PDG_ID.PDG_Type(hadronproducedID)), "HADRON MASS IN THE BARREEEEEE" #print "SUCESSFULLY DETERMINED A MASS" stringcontent = self.Getbaryonstringcontent(hadronproducedID,decayingquarknumber,recievingdiquark) # takes the (baryon, diquark) IDs. that have just been found decayingstring = copy.deepcopy(newstring) #print stringcontent, "stringcontent from the module" ''' If the produced particle is a meson, leaves behind a quark remnant at the end of the string ''' if hadroncodetest.isMeson() is True: stringcontent = self.Findstringcontent(decayingquarknumber,hadronproducedID) # finds [quark, antiquark] of the string #print stringcontent, "DO WE GOT A PROBLEM HERE" ''' Get out the string information (ie the quark information) ''' boostedstring = self.Booststringforward(decayingstring) quark1 = boostedstring.Getq() antiquark1 = boostedstring.Getqbar() quark1vector4D = quark1.Getvector4D() antiquark1vector4D = antiquark1.Getvector4D() ''' define particle produced values ''' # Initialise the particle for manipulation later. (hadron is object k) hadronmomentum = Fourvector.vector4D(1.,1.,1.,1.) # placeholder (used for class creation), is reset later hadron = Particle.particle4D(hadronproducedID,hadronmomentum) hadronmass = hadron.Getmass() '''Create p+, p-''' #print antiquark1vector4D.Getvector(), "#PRINT VECOTRS" #print quark1vector4D.Getvector() if quark1vector4D[3] < 0: p_plus = quark1vector4D[0] - quark1vector4D[3] p_minus = antiquark1vector4D[0] + antiquark1vector4D[3] if quark1vector4D[3] > 0: p_plus = quark1vector4D[0] + quark1vector4D[3] p_minus = antiquark1vector4D[0] - antiquark1vector4D[3] ''' Find the quark content of the string ''' #print stringcontent[0], "stringcontent 0 " #print stringcontent[1], "stringcontent 1 " ''' Try 100 hundred times to get a successful kperp and z value for the current string decay ''' n = 0 while True: n = n+1 ##print "Are we stuck" #print "stringmass", boostedstring.Getstringmass() #print "hadronmass", hadronmass #print antiquark1vector4D.Getvector(), "#PRINT VECOTRS" #print quark1vector4D.Getvector() ''' Get k perp value ''' kperp = self.Getkperphitmiss(boostedstring) # 0.305 #print kperp, "kperp" ''' Get z value ''' z_plus = self.Getzhitmiss(boostedstring,kperp,hadronmass) # 0.24 z_minus = 1 - z_plus #print z_plus, "z_plus" ''' Create the k+- values ''' k_plus = z_plus*p_plus k_minus = (hadronmass*hadronmass + kperp*kperp) / (z_plus*p_plus) ##print k_plus, "k_plus" ##print k_minus, "k_minus" ''' Create the angles for future resolving ''' ''' phi is isotropic, and taken as angle to the quark. pi is added to phi to get the hadron angle ''' q_phi = 2*numpy.pi*random.random() k_phi = q_phi + numpy.pi qnew_cosphi = numpy.cos(q_phi) qnew_sinphi = numpy.sin(q_phi) k_cosphi = numpy.cos(k_phi) k_sinphi = numpy.sin(k_phi) ''' Create the final vectors ''' qnew_plus = z_minus * p_plus #print z_minus #print p_plus, "P PLUS" qnew_minus = (kperp*kperp) / (z_minus * p_plus) ''' Arrange arrays of [p+, p_, pcostheta, psintheta] ''' qnew = [qnew_plus, qnew_minus, kperp*qnew_cosphi, kperp*qnew_sinphi] #print qnew, "QNEW" knew = [k_plus, k_minus, kperp*k_cosphi, kperp*k_sinphi] #print knew, "KNEW" antiqnew = [0,p_minus - k_minus - qnew_minus, 0, 0] #print antiqnew, "ANTIQNEW" ''' From the arrays constructed above, create the vectors E,p ''' ''' Start with the particle ''' k_E = (k_plus + k_minus) /2 k_px = knew[2] k_py = knew[3] k_pz = (k_plus - k_minus) /2 kmom = Fourvector.vector4D(k_E,k_px,k_py,k_pz) ''' And now for the quark in the string ''' q_E = (qnew[0]+qnew[1])/2 q_px = qnew[2] q_py = qnew[3] q_pz = (qnew[0]-qnew[1])/2 qmom = Fourvector.vector4D(q_E,q_px,q_py,q_pz) ''' And now for the antiquark in the string ''' antiq_E = (antiqnew[0] + antiqnew[1]) /2 antiq_px = antiqnew[2] antiq_py = antiqnew[3] antiq_pz = (antiqnew[0] - antiqnew[1]) /2 antiqmom = Fourvector.vector4D(antiq_E,antiq_px,antiq_py,antiq_pz) ''' Testing the dynamics of the system - momentum should be conserved ''' totalmom = antiqmom+qmom+kmom ##print p_plus*p_minus, "total cmf momentum of the system originally, i.e. 2E" ##print totalmom*totalmom, "Invariant mass squared of the final system" ''' Now need to boost the system back into the lab frame ''' ''' Adjust the quarks and create a new string, and boost to lab frame ''' #print stringcontent, "STRINGCONTENT" quark2 = Particle.particle4D(float(stringcontent[0]),quark1.Getvector4D()) #print hadronproducedID, "HADRON ID" ##print stringcontent[1], "ANTI QUARK NUMBER" antiquark2 = Particle.particle4D(float(stringcontent[1]),antiquark1.Getvector4D()) quark2.Setmom(qmom) antiquark2.Setmom(antiqmom) quark1.Setmom(qmom) antiquark1.Setmom(antiqmom) newstring = MRS.mrs4D(quark2,antiquark2) newstring_labframe = self.Booststringback(newstring) # Final string, in the lab frame #print newstring_labframe.Getstringcontent(), "LABFRAME CONTENT" #testthequark = newstring_labframe.Getq() #print testthequark.Getinvariantmass(), "invariant mass of the quark in the string" ''' Now need to boost then adjust the produced hadron ''' kmomrotated = self.__rotateboost.Rotatebackwards(kmom) # rotate out or rotated frame kmomboosted = self.__lorentzboost/kmomrotated # boost into the lab frame (original frame) hadron.Setmom(kmomboosted) ##print Decaytables.Findminandmaxpairmass(newstring_labframe)[1], "testing the condition for failure here" ##print newstring_labframe.Getstringmass(), "stringmass in the new labframe" ##print Decaytables.Stringdecaysmallesthadron(newstring_labframe), "result of the decaytables testing shit, searching for error" ##print newstring_labframe.Getstringcontent(), "stringcontent" #if n > 3: #sys.exit() ''' Check validity of the decay (cons of energy) ''' if qnew_minus + k_minus >= quark1vector4D[0] + antiquark1vector4D[0]: #print qnew_minus #print k_minus #print quark1vector4D[0] #print antiquark1vector4D[0] #print "CONDITION 1 FAILED" continue if quark2.Checkquark() is True and antiquark2.Checkquark() is True: meson = Decaytables.GetFailsafe1hadron(newstring_labframe) #print meson, "STRINGDECAY ERROR MESSAGE. THIS IS WHAT TRYING TO GET MASS OF" #mass = Decaytables.Getmass(meson) if meson == 0: continue mass = Decaytables.Getmass(meson) if newstring_labframe.Getstringmass() <= mass: #print "CONDITION 2 FAILED" continue break if Decaytables.GetFailsafe1hadron(newstring_labframe) == 0: # if no possible stringcollapse avaiable, try and produce something with less mom frac #print "CONDITION 3 FAILED" continue # previous findminandmaxpairmass(string)[0] else: break kaoncheck = self.Checkforkaons(hadronproducedID) hadron.SetID(kaoncheck) #print "STRING SUCCESSFULLY DECAYED" return [newstring_labframe, hadron] # returns the new string and a hadron, both boosted into the lab frame
def Twobodydiquarks(self,string,diquark1, diquark2): stringvec4D = string.Gettotalvector4D() boost = Boosts.boost4D(stringvec4D) cmsvector = boost.GetCMF() Mass = cmsvector[0] # string mass ''' Get the hadron masses ''' Decaytables = Decaydictionary.Decays() #hadronpair = Decaytables.Failsafe2complete(string) #need to get the diquarks for string ends. hadron1code = diquark1 #print hadron1code, "hadron1code from diquark twobody" hadron2code = diquark2 #print hadron2code, "hadron2code from diquark twobody" mass1 = Decaytables.Getmass(hadron1code) mass2 = Decaytables.Getmass(hadron2code) mom3 = Mass/2 mom3 *= self.Sqrtlambda1(Mass,mass1,mass2) randomphi = random.random() randomtheta = random.uniform(-1,1) phi = 2.*numpy.pi*randomphi sinphi = numpy.sin(phi) cosphi = numpy.cos(phi) theta = numpy.pi*randomtheta sintheta = numpy.sin(theta) costheta = numpy.cos(theta) mom = Fourvector.vector4D(0.,sintheta*cosphi,sintheta*sinphi,costheta) mom *= mom3 E1 = numpy.sqrt(mass1*mass1+mom3*mom3) E2 = numpy.sqrt(mass2*mass2+mom3*mom3) finalvec1 = Fourvector.vector4D() finalvec1[0] = E1 finalvec1 += mom finalvec2 = Fourvector.vector4D() finalvec2[0] = E2 finalvec2 -= mom finalvec1 = boost/finalvec1 finalvec2 = boost/finalvec2 ''' reset the final vecs to represent massless diquarks. Just need the flavour assignment ''' finalvec1 = copy.deepcopy(string.Getqvector4D()) finalvec2 = copy.deepcopy(string.Getqbarvector4D()) finalhadron1 = Particle.particle4D(hadron1code,finalvec1) finalhadron2 = Particle.particle4D(hadron2code,finalvec2) if hadron1code > 0: newstring = MRS.mrs4D(finalhadron1,finalhadron2) if hadron1code < 0: newstring = MRS.mrs4D(finalhadron2,finalhadron1) # try to keep the negative / positive ids in the relative placements (kind of important) #print newstring.Getstringcontent(), "CHECKING THE TWO BODY MODULE" return newstring
def Failsafe1(self,string): ''' Get Produced hadron & photon masses ''' Decaytables = Decaydictionary.Decays() Failsafe1hadron = Decaytables.GetFailsafe1hadron(string) if Failsafe1hadron == 0: Failsafe1hadron = 22 # set to a photon #print "Failsafe1 being fed an unphysical string - setting the hadron to photon to avoid crash but investigate the problem" #print string.Getstringmass(), "stringmass" #print string.Getstringcontent(), "stringcontent" #print Failsafe1hadron hadronmass = Decaytables.Getmass(Failsafe1hadron) # mass1 #print hadronmass, "hadronmass" photonmass = 0 # mass 2 ''' Get boost class which contains useful boosting functions ''' string4vector = string.Gettotalvector4D() boost = Boosts.boost4D(string4vector) ''' CMF mass of the string (mass of decaying object) ''' cmsvector = boost.GetCMF() Mass = cmsvector[0] mom3 = Mass/2 mom3 *= self.Sqrtlambda1(Mass,hadronmass,photonmass) ''' Do the random angle generation ''' randomphi = random.random() randomtheta = random.uniform(-1,1) phi = 2.*numpy.pi*randomphi sinphi = numpy.sin(phi) cosphi = numpy.cos(phi) theta = numpy.pi*randomtheta sintheta = numpy.sin(theta) costheta = numpy.cos(theta) ''' start setting the 4 vectors of the products ''' mom = Fourvector.vector4D(0.,sintheta*cosphi,sintheta*sinphi,costheta) mom *= mom3 E1 = numpy.sqrt(hadronmass*hadronmass+mom3*mom3) E2 = numpy.sqrt(photonmass*photonmass+mom3*mom3) finalvec1 = Fourvector.vector4D() finalvec1[0] = E1 finalvec1 += mom finalvec2 = Fourvector.vector4D() finalvec2[0] = E2 finalvec2 -= mom ''' Boost back into the lab frame ''' finalvec1 = boost/finalvec1 #hadron finalvec2 = boost/finalvec2 #photon ''' Create the particles and return them in a list ''' Failsafe1hadron = self.Checkforkaons(Failsafe1hadron) finalhadron = Particle.particle4D(Failsafe1hadron,finalvec1) finalphoton = Particle.particle4D(22,finalvec2) if abs(finalhadron.Getcode()) == 311: print "FOUND IT" sys.exit() return [finalhadron, finalphoton]
mom1 = Fourvector.vector4D(numpy.sqrt(41),3.,4.,4.) mom2 = Fourvector.vector4D(numpy.sqrt(45),2.,4.,5.) mom3 = Fourvector.vector4D(numpy.sqrt(101),9,4.,2.) mom4 = Fourvector.vector4D(6,2,4.,4.) mom5 = Fourvector.vector4D(6,-2.,-4.,-4.) ''' momenta for 91.2 GeV ''' mom10 = Fourvector.vector4D(91.2/2,35.,20.,numpy.sqrt(454.36)) mom11 = Fourvector.vector4D(91.2/2,-35.,-20.,-numpy.sqrt(454.36)) ''' Create some quarks ''' dquark = Particle.particle4D(1,mom10) uquark = Particle.particle4D(2,mom10) squark = Particle.particle4D(3,mom10) cquark = Particle.particle4D(4,mom10) bquark = Particle.particle4D(5,mom10) tquark = Particle.particle4D(6,mom10) ''' Create some antiquarks ''' antidquark = Particle.particle4D(-1,mom11) antiuquark = Particle.particle4D(-2,mom11) antisquark = Particle.particle4D(-3,mom11) anticquark = Particle.particle4D(-4,mom11) antibquark = Particle.particle4D(-5,mom11) antitquark = Particle.particle4D(-6,mom11)
def Failsafe2(self,string): # IN SITU. NEEDS NEW TABLES TO BE CODED. stringvec4D = string.Gettotalvector4D() boost = Boosts.boost4D(stringvec4D) cmsvector = boost.GetCMF() Mass = cmsvector[0] # string mass ''' Get the hadron masses ''' Decaytables = Decaydictionary.Decays() hadronpair = Decaytables.Failsafe2complete(string) hadron1code = hadronpair[0] hadron2code = hadronpair[1] mass1 = Decaytables.Getmass(hadron1code) if mass1 == 0: print "mass 1 == 0" print hadron1code, "hadron1code" print hadron2code, "hadron2code" sys.exit() mass2 = Decaytables.Getmass(hadron2code) mom3 = Mass/2 mom3 *= self.Sqrtlambda1(Mass,mass1,mass2) randomphi = random.random() randomtheta = random.uniform(-1,1) phi = 2.*numpy.pi*randomphi sinphi = numpy.sin(phi) cosphi = numpy.cos(phi) theta = numpy.pi*randomtheta sintheta = numpy.sin(theta) costheta = numpy.cos(theta) mom = Fourvector.vector4D(0.,sintheta*cosphi,sintheta*sinphi,costheta) mom *= mom3 E1 = numpy.sqrt(mass1*mass1+mom3*mom3) E2 = numpy.sqrt(mass2*mass2+mom3*mom3) finalvec1 = Fourvector.vector4D() finalvec1[0] = E1 finalvec1 += mom finalvec2 = Fourvector.vector4D() finalvec2[0] = E2 finalvec2 -= mom finalvec1 = boost/finalvec1 finalvec2 = boost/finalvec2 finalvec1row = finalvec1.Getvector() finalvec2row = finalvec2.Getvector() for i in range(4): if math.isnan(finalvec1row[i]) == True: finalvec1 = Fourvector.vector4D(mass1,0,0,0) if math.isnan(finalvec2row[i]) == True: finalvec2 = Fourvector.vector4D(mass2,0,0,0) # if we have nan values, then produce them at reast. see how this works print Mass, "stringmass" print "reached the problem with double kaon produictiion" sys.exit() finalhadron1 = Particle.particle4D(hadron1code,finalvec1) finalhadron2 = Particle.particle4D(hadron2code,finalvec2) return [finalhadron1, finalhadron2]
def Convertfromhepmc(): reader = hepmc.IO_GenEvent("INPUT", "r") # ryan.hepmc is the file for PYTHIA stuff evtnum = 0 # should be zero noheavyevents = 0 evt = hepmc.GenEvent() reader.fill_next_event(evt) totaleventlist = [] while evt.particles_size(): # evtnum < 50000 ''' Loop for each event. I.e. each list of particles ''' subeventlist = [] evtnum+=1 #print "Event %d: " % evtnum, evt #print "Particles: ", evt.particles() #print "Num particles: ", evt.particles_size() #print "Num vertices: ", evt.vertices_size() #for p in evt.particles(): # m = p.momentum() # "X,Y,Z,E" # print m fsps = evt.fsParticles() #print "FS particles: ", fsps #print "Num FS particles: ", len(fsps) if evtnum % 100 == 0: print "Event %d" % evtnum for p in fsps: ''' Build the list of final state particles in PyLund, and fill their properties ''' #print p m = p.momentum() # E,x,y,z colour = p.flow(1) anticolour = p.flow(2) #print "1", colour, "2", anticolour ''' Build properties into PyLund particle class and append the particle to the sublist ''' partfv = Fourvector.vector4D(m.e(),m.px(),m.py(),m.pz()) ID = p.pdg_id() newpart = Particle.particle4D(ID,partfv)# #print newpart.Getinvariantmass(), "particle invariant mass" newpart.Setcolour(colour) newpart.Setanticolour(anticolour) subeventlist.append(newpart) ''' Perform some checks on the list -- current edition removes photons and vetoes heavy events ''' if Vetoheavies(subeventlist) == True: # If event contains a heavy quark. go to next iteration before append. noheavyevents += 1 #print "\n\n" evt.clear() evt = reader.get_next_event() continue subeventlist = Removephotons(subeventlist) # remove the photons from the event. #print "Num fs particles", len(subeventlist) # WE REMOVE THE PHOTONS. NO FS PARTICLES DOES NOT INCLUDE THE PHOTONS. ''' The call the colour ordering function ''' #print subeventlist subeventlist = Colourorderlist(subeventlist) #print subeventlist, "event list after colour ordering" #print checkcolours(subeventlist) #sys.exit() subeventlist = masslessmomenta(subeventlist) # attempting the massels mom subeventlist = Fixlowenergy(subeventlist) #print subeventlist, "event list after fixing low nergy gluons" #print energies(subeventlist) #print checkquark(subeventlist) #sys.exit() subeventlist = Gluonsplitting.Splitgluons(subeventlist) #print subeventlist, "event list after splitting the gluons" #print len(subeventlist), "number of particles fed into string former" subeventlist = Stringformer.Formstrings(subeventlist) # Convert the lists to strings! #print subeventlist, "sublist after forming all the strings." #sys.exit() totaleventlist.append(subeventlist) #print "\n\n" evt.clear() evt = reader.get_next_event() #print noheavyevents return totaleventlist # returns a list of lists that contain strings ready for feeding into PyLund!
def Getmh(left,dec_g,right,z,splitflavour): # return False if conditions not met. Otherwise return normal vector output. Decaytables = Decaydictionary.Decays() gvec4Dx = dec_g.Getvector4D() gvec4D = copy.deepcopy(gvec4Dx) sgl_flavour = copy.deepcopy(splitflavour) if right.Checkgluon() == True: # particle on the right is a gluon. only have to consider the left hand side particle. #print "right particle is gluon, check that part" # Need the information of the quark / antiquark on the left. leftvector4D = left.Getvector4D() #print leftvector4D, "left vector" if left.Checkdiquark() == False: # left is a quark. Have to assign according to that idea if left.GetID() > 0: # if the left is the quark. need antiflavour if splitflavour > 10: # i.e. were producing a diquark sgl_flavour = copy.deepcopy(splitflavour) # we want the positive again. # UNLESS THE FLAVOUR CREATED IS A DIQUARK if splitflavour < 10: # i.e. we not producing a diquark sgl_flavour *= -1 # we want the negative quark on the left of the gluon split if left.GetID() < 0: # we have an anti quark on the left somehow??. Perhaps we've already had some diquark produciton :/ if splitflavour > 10: sgl_flavour = copy.deepcopy(splitflavour) * -1 if splitflavour < 10: sgl_flavour = copy.deepcopy(splitflavour) if left.Checkdiquark() == True: if left.GetID() < 0: # negative diquark sgl_flavour = copy.deepcopy(splitflavour) * -1 if left.GetID() > 0: # positive diquark #print "we haev a positive diquark" #print left.GetID(), "left ID" sys.exit() sgl_flavour = copy.deepcopy(splitflavour) sgl_vec4D = copy.deepcopy(gvec4D) #print sgl_vec4D.Getvector()[0], "Energy of the gluon" sgl_vec4D *= z #print "scaled vector", sgl_vec4D # get the scaled momentum. sgl = Particle.particle4D(sgl_flavour, sgl_vec4D) # Create a temp string to test for FS1 hadron. I.e. if there is a small hadron that can be made. #print left.GetID(), "left ID" #print left.Getvector(), "left vector" #print sgl_flavour, "sgl flavour" #print sgl.Getvector(), "sgl vector" string = MRS.mrs4D(left,sgl) #print string.Getstringmass(), "string mass of the left,sgl pair" fs1hadron = Decaytables.GetFailsafe1hadron(string) #print fs1hadron, "fs1hadron in the right split code" if fs1hadron == 0: return False # condition failed. cant produce a hadron. fs1mass = PDG_ID.PDG_Type.mass(PDG_ID.PDG_Type(fs1hadron)) #print fs1mass totalmom = sgl_vec4D + leftvector4D if totalmom*totalmom < (fs1mass*fs1mass): # Condition that the resultant qqbar pair is heavy enough to at least form a hadron. return False # Condition failed. Need to reloop again for different z. # Provided above conditions are satisfied, return the particles in correct sides based on nature of the left quark. # create the other particle sgr_flavour = copy.deepcopy(sgl_flavour) * -1 sgr_vec4D = copy.deepcopy(gvec4D) sgr_vec4D *= (1-z) ''' Create a new proxy particle to form a string with the right hand side to check cons stuff ''' copyright = copy.deepcopy(right) newrightflavour = 1 if abs(sgr_flavour) > 10: # we have a diquark if sgr_flavour > 0: # positive diquark newrightflavour = 1 if sgr_flavour < 0: newrightflavour = -1 if abs(sgr_flavour) < 10: # we ahve a regular quarks if sgr_flavour > 0: # positive quark newrightflavour = -1 if sgr_flavour < 0: newrightflavour = 1 copyright.SetID(newrightflavour) #print copyright.Getvector(), "vector of the right hand side particle" #print sgr_vec4D, "vector of the right hand side gluon after split. They must be collinear or smthing" sgr = Particle.particle4D(sgr_flavour,sgr_vec4D) string2 = MRS.mrs4D(sgr,copyright) #print string2.Getstringmass(), "stringmass of the second pseudo string" fs1hadron2 = Decaytables.GetFailsafe1hadron(string2) if fs1hadron2 == 0: return False # new conditional if abs(splitflavour) > 10: # we have a diquark produced rightvec4D = right.Getvector4D() sgr4D = sgr.Getvector4D() inv = rightvec4D + sgr4D invmass = numpy.sqrt(inv * inv) if invmass < 2.5: # invariant mass is less than two for the decaying gluon and the right hand side particle. then veto diquark production return False # Flavours already flipped from the above condition. Should always be correct relative to the left and eachother. return [sgl,sgr] if right.Checkgluon() == False: # so the right side is a quark. need to account for both sides having sufficient mass to form hadrons. #print "right particle is a quark, see that algorithm" if left.Checkdiquark() == False: #print "left is not diquark" #print splitflavour, "splitflavour in this party" if left.GetID() > 0: # if the left is the quark. need antiflavour if splitflavour > 10: # i.e. were producing a diquark sgl_flavour = copy.deepcopy(splitflavour) # we want the positive again. # UNLESS THE FLAVOUR CREATED IS A DIQUARK if splitflavour < 10: # i.e. we not producing a diquark sgl_flavour *= -1 # we want the negative quark on the left of the gluon split if left.GetID() < 0: # we have an anti quark on the left somehow??. Perhaps we've already had some diquark produciton :/ #print "left ID is less than zero" if splitflavour > 10: "we've reached the left neg, g diquark part" sgl_flavour = copy.deepcopy(splitflavour) * -1 #print left.GetID() #print sgl_flavour, "flavour of sgl" if splitflavour < 10: sgl_flavour = copy.deepcopy(splitflavour) if left.Checkdiquark() == True: if left.GetID() < 0: # negative diquark sgl_flavour = copy.deepcopy(splitflavour) * -1 if left.GetID() > 0: # positive diquark sgl_flavour = copy.deepcopy(splitflavour) sgl_vec4D = copy.deepcopy(gvec4D) print sgl_vec4D, "sgl vec4D" print sgl_vec4D * sgl_vec4D sgl_vec4D *= z sgr_vec4D = copy.deepcopy(gvec4D) print sgr_vec4D, "sgrvec4D" sgr_vec4D *= (1-z) sgr_flavour = copy.deepcopy(sgl_flavour) * -1 # sgr is the anti of the sgl #print right.GetID(), "right ID" #print left.GetID(), "left ID" #print sgr_flavour, "sgrflavour" #print sgl_flavour, "sglflavour" sgl = Particle.particle4D(sgl_flavour,sgl_vec4D) sgr = Particle.particle4D(sgr_flavour,sgr_vec4D) string1 = MRS.mrs4D(left,sgl) #print string1.Getstringcontent(), "stringcontent of string 1 in gluon splitting rigt hand is quark" string2 = MRS.mrs4D(sgr,right) #print string2.Getstringcontent(), "stringcontent of string 2 in gs right hand is quark" #print string1.Getstringmass(), string2.Getstringmass(), "string masses of 1,2 respectuively" fs1hadron1 = Decaytables.GetFailsafe1hadron(string1) #print fs1hadron1 if fs1hadron1 == 0: return False fs1hadron2 = Decaytables.GetFailsafe1hadron(string2) #print fs1hadron2 if fs1hadron2 == 0: return False return [sgl,sgr]