def setUp(self): self.species = species.Species(0, 1, 1, []) self.attacker = species.Species(0, 1, 1, []) self.attacker.setTraits([trait.Trait.carnivore]) self.defender = species.Species(0, 1, 1, []) self.neighborleft = species.Species(0, 1, 1, []) self.neighborright = species.Species(0, 1, 1, [])
def setUp(self): self.player = player.Player(1, [], 0) self.strat = strategy.Strategy() self.carnivore = species.Species(0, 1, 1, []) self.carnivore.setTraits([trait.Trait.carnivore]) self.fat_carnivore = species.Species(0, 1, 1, []) self.fat_carnivore.setTraits([trait.Trait.carnivore]) self.fat_carnivore.setBodySize(5) self.herbavore = species.Species(0, 1, 1, []) self.fat_herbavore = species.Species(0, 1, 1, []) self.fat_herbavore.setBodySize(4) self.fat_tissue = species.Species(0, 1, 1, []) self.fat_tissue.setBodySize(3) self.fat_tissue.setTraits([trait.Trait.fat_tissue]) self.fat_fat_tissue = species.Species(0, 1, 1, []) self.fat_fat_tissue.setBodySize(6) self.fat_fat_tissue.setTraits([trait.Trait.fat_tissue]) self.opherb = species.Species(0, 1, 1, []) self.opfatherb = species.Species(0, 1, 1, []) self.opfatherb.setBodySize(4) self.opponent1 = player.Player(1, [], 0) self.opponent1.setSpeciesBoards([self.opherb, self.opfatherb]) self.opponents = [self.opponent1] self.dealer = dealer.Dealer() self.dealer.setListOfPlayers([self.player, self.opponent1]) self.dealer.setWateringHole(4)
def parse_loSpecies(self, LOS): """ make a list of Species from a JSON LOS. A JSON Species+ is: [["food",Nat], ["body",Nat], ["population",Nat], ["traits",LOT] ["fat-food" ,Nat]] """ species_list = [] for speciesboard in LOS: keywords = ((speciesboard[0][0] == "food") and (speciesboard[1][0] == "body") and (speciesboard[2][0] == "population") and (speciesboard[3][0] == "traits")) if speciesboard and keywords: this_species = species.Species( speciesboard[0][1], speciesboard[1][1], speciesboard[2][1], self.parse_traits(speciesboard[3][1])) if this_species.hasFatTissue(): try: this_species.setFatFood(speciesboard[4][1]) except IndexError: pass species_list.append(this_species) elif not keywords: raise Exception("Keywords don't match") return species_list
def __speciate(self, report=False): """ Group chromosomes into species by similarity """ if self._gtype == Blu_Chromosome: for indiv in self.__population: indiv.updateModPointers() # Speciate the population for individual in self: found = False for s in self.__species: if individual.distance( s.representant) < Config.compatibility_threshold: s.add(individual) found = True break if not found: # create a new species for this lone chromosome self.__species.append(species.Species(individual)) # python technical note: # we need a "working copy" list when removing elements while looping # otherwise we might end up having sync issues for s in self.__species[:]: # this happens when no chromosomes are compatible with the species if len(s) == 0: if report: print "Removing species %d for being empty" % s.id # remove empty species self.__species.remove(s) if self._gtype == Mod_Chromosome: Config.mod_species = [s.id for s in self.__species if len(s) > 0] self.__set_compatibility_threshold()
def get_input_spp(sppfile): spp = open(sppfile, "r").read().splitlines() input_species = {} for s in spp: s_clean = s.replace("_", " ") log.debug("Making species object for '%s'" % (s)) input_species[s_clean] = species.Species(s_clean, s) return input_species
def testCreationFromPlanet(self): # What info do we need from a planet? config = { "planet": { "world_type": "Ocean", "size": "Standard", "surface_temp": "287.4", "hydro_cover": 80 } } new_species = species.Species(self.random_seed, config)
def get_species(session, uri): """ using the URI given of a certain species , the species details are retrieved and returned from the API """ if uri is None: return one_species = session.get(uri).json() if one_species is not None: species_obj = species.Species( one_species['name'], one_species['average_lifespan'], get_world(session, one_species['homeworld'])) return species_obj
def get_aln_spp(alnfile): log.debug("Opening alignment '%s'" % (alnfile)) aln = open(alnfile, "r") sites = int(aln.readline().split()[1]) #get a dictionary of names in the smith alignment, keyed by genus aln_spp = {} for line in iter(aln): name = line.split()[0] name_clean = name.replace("_", " ") dna = line.split()[1] data = sites - dna.count("-") s = species.Species(name_clean, name) s.data = data aln_spp[name_clean] = s return aln_spp
def __speciate(self): """ Group chromosomes into species by similarity """ # Speciate the population for c in self: found = False for s in self.__species: if s.representative.id == c.id: s.add(c) found = True break # if c.species_id is not None try this species first if c.species_id == s.id and not found: if c.distance(s.representative) < Config.compatibility_threshold: s.add(c) found = True break if not found: for s in self.__species: if c.distance(s.representative) < Config.compatibility_threshold: s.add(c) #print 'chromo %s added to species %s' %(c.id, s.id) found = True break # we found a compatible species, so let's skip to the next if not found: # create a new species for this lone chromosome self.__species.append(species.Species(c)) # Controls compatibility threshold if len(self.__species) > Config.species_size: Config.compatibility_threshold += Config.compatibility_change elif len(self.__species) < Config.species_size: if Config.compatibility_threshold > Config.compatibility_change: Config.compatibility_threshold -= Config.compatibility_change else: print 'Compatibility threshold cannot be changed (minimum value has been reached)'
with open(outputFileName + '.dat', 'w') as outputFile: for config in levelList: outputFile.write('\n') for level in config.term.levels: writeStr = config.ID + ', ' + str(level.J) + ', ' + str( level.energy) if outputFileName == 'calculated': writeStr += ' ' + config.method + '\n' else: writeStr += '\n' outputFile.writelines(writeStr) return levelList if __name__ == '__main__': O = species.Species('O') #allSpecies = [allSpecies] NIST = readNISTSpectra(O) theory = calculateExpectedStates(O, 5) calcEnergy = CalcEnergy(5, O, NIST, theory, O) allLevels = calcEnergy.populateTheory() for config in allLevels: if config.term.checkLevelEnergies() != None: print(config.ID, config.core.term.getTermString())
import matplotlib.pyplot as plt ############### SORT LEVELS ################## constants = util.Constants() nMax = 30 speciesList = [ 'C', 'C+', 'N', 'N+', 'N++', 'O', 'O+', 'O++', 'F+', 'F++', 'F+++', 'Ne++', 'Ne+++' ] allSpecies = [] for speciesStr in speciesList: speciesObj = species.Species(speciesStr) allSpecies.append([speciesObj, spectra.readNISTSpectra(speciesObj)]) O = species.Species('O') N = species.Species('N') OI = species.Species('O+') NI = species.Species('N+') use = NI NIST = spectra.readNISTSpectra(use) theory = spectra.calculateExpectedStates(use, nMax) calcEnergy = spectra.CalcEnergy(nMax, use, NIST, theory, allSpecies) completeLevels, calculatedLevels = calcEnergy.populateTheory()
def testCreationWithConstraints(self): config = {"species": {"land_dwelling": True, "habitat": "Arctic"}} new_species = species.Species(self.random_seed, config) self.assertEqual("Arctic", new_species.habitat) self.assertTrue(new_species.sphere)
def setUp(self): self.random_seed = 1 # Ensure that our tests are reproducible self.species = species.Species(self.random_seed)
def setUp(self): self.parse_json = parse_json.ParseJSON() self.false = json.dumps(False) self.spec1 = species.Species(0, 1, 1, ["carnivore"]) self.spec2 = species.Species(1, 3, 3, ["herding"]) self.spec3 = species.Species(1, 2, 4, ["carnivore", "ambush"]) self.spec4 = species.Species(0, 3, 2, []) self.spec5 = species.Species(0, 4, 2, ["carnivore"]) self.spec6 = species.Species(1, 3, 3, ["herding"]) self.spec7 = species.Species(1, 2, 4, ["carnivore", "ambush"]) self.spec8 = species.Species(0, 1, 2, []) self.spec9 = species.Species(0, 1, 1, ["symbiosis"]) self.spec10 = species.Species(0, 3, 1, ["warning-call"]) self.spec11 = species.Species(2, 2, 2, []) self.spec12 = species.Species(0, 1, 1, []) self.spec13 = species.Species(0, 1, 1, []) self.spec14 = species.Species(0, 5, 1, ["fat-tissue"]) self.spec14.setFatFood(5) self.spec15 = species.Species(0, 6, 1, ["warning-call"]) self.spec16 = species.Species(2, 2, 2, []) self.spec17 = species.Species(0, 1, 1, []) self.spec18 = species.Species(0, 1, 1, []) self.spec19 = species.Species(0, 3, 2, ["carnivore", "fat-tissue"]) self.spec19.setFatFood(3) self.spec20 = species.Species(3, 3, 6, []) self.spec21 = species.Species(0, 5, 4, []) self.spec22 = species.Species(2, 2, 2, []) self.player1 = player.Player(1, [self.spec1], 0) self.player2 = player.Player(2, [self.spec2, self.spec3], 0) self.player3 = player.Player(3, [self.spec4], 0) self.player4 = player.Player(1, [self.spec5], 0) self.player5 = player.Player(2, [self.spec6, self.spec7], 0) self.player6 = player.Player(3, [self.spec8], 0) self.player7 = player.Player(1, [self.spec9], 0) self.player8 = player.Player(2, [self.spec10, self.spec11], 0) self.player9 = player.Player(3, [self.spec12], 0) self.player10 = player.Player(1, [self.spec13], 0) self.player11 = player.Player(2, [self.spec14, self.spec15], 0) self.player12 = player.Player(3, [self.spec16], 0) self.player13 = player.Player(1, [self.spec17], 0) self.player14 = player.Player(2, [self.spec18, self.spec19], 0) self.player15 = player.Player(3, [self.spec20], 0) self.player16 = player.Player(1, [], 0) self.json_spec1 = [["food", 0], ["body", 1], ["population", 1], ["traits", ["carnivore"]]] self.json_spec2 = [["food", 1], ["body", 3], ["population", 3], ["traits", ["herding"]]] self.json_spec3 = [["food", 1], ["body", 2], ["population", 4], ["traits", ["carnivore", "ambush"]]] self.json_spec4 = [["food", 0], ["body", 3], ["population", 2], ["traits", []]] self.json_spec5 = [["food", 0], ["body", 4], ["population", 2], ["traits", ["carnivore"]]] self.json_spec6 = [["food", 1], ["body", 3], ["population", 3], ["traits", ["herding"]]] self.json_spec7 = [["food", 1], ["body", 2], ["population", 4], ["traits", ["carnivore", "ambush"]]] self.json_spec8 = [["food", 0], ["body", 1], ["population", 1], ["traits", []]] self.json_spec9 = [["food", 0], ["body", 1], ["population", 1], ["traits", ["symbiosis"]]] self.json_spec10 = [["food", 0], ["body", 3], ["population", 1], ["traits", ["warning-call"]]] self.json_spec11 = [["food", 2], ["body", 2], ["population", 2], ["traits", []]] self.json_spec12 = [["food", 0], ["body", 1], ["population", 1], ["traits", []]] self.json_spec13 = [["food", 0], ["body", 1], ["population", 1], ["traits", []]] self.json_spec14 = [["food", 0], ["body", 5], ["population", 1], ["traits", ["fat-tissue"]], ["fat-food", 5]] self.json_spec15 = [["food", 0], ["body", 6], ["population", 1], ["traits", ["warning-call"]]] self.json_spec16 = [["food", 2], ["body", 2], ["population", 2], ["traits", []]] self.json_spec17 = [["food", 0], ["body", 1], ["population", 1], ["traits", []]] self.json_spec18 = [["food", 0], ["body", 1], ["population", 1], ["traits", []]] self.json_spec19 = [["food", 0], ["body", 3], ["population", 2], ["traits", ["carnivore", "fat-tissue"]], ["fat-food", 3]] self.json_spec20 = [["food", 3], ["body", 3], ["population", 6], ["traits", []]] self.json_spec21 = [["food", 0], ["body", 5], ["population", 4], ["traits", []]] self.json_spec22 = [["food", 2], ["body", 2], ["population", 2], ["traits", []]] self.json_player1 = [["id", 1], [ "species", [[["food", 0], ["body", 1], ["population", 1], ["traits", ["carnivore"]]]] ], ["bag", 0]] self.json_player2 = [["id", 2], [ "species", [[["food", 1], ["body", 3], ["population", 3], ["traits", ["herding"]]], [["food", 1], ["body", 2], ["population", 4], ["traits", ["carnivore", "ambush"]]]] ], ["bag", 0]] self.json_player3 = [["id", 3], [ "species", [[["food", 0], ["body", 3], ["population", 2], ["traits", []]]] ], ["bag", 0]] self.json_player4 = [["id", 1], [ "species", [[["food", 0], ["body", 4], ["population", 2], ["traits", ["carnivore"]]]] ], ["bag", 0]] self.json_player5 = [["id", 2], [ "species", [[["food", 1], ["body", 3], ["population", 3], ["traits", ["herding"]]], [["food", 1], ["body", 2], ["population", 4], ["traits", ["carnivore", "ambush"]]]] ], ["bag", 0]] self.json_player6 = [["id", 3], [ "species", [[["food", 0], ["body", 1], ["population", 2], ["traits", []]]] ], ["bag", 0]] self.json_player7 = [["id", 1], [ "species", [[["food", 0], ["body", 1], ["population", 1], ["traits", ["symbiosis"]]], [["food", 0], ["body", 3], ["population", 1], ["traits", ["warning-call"]]]] ], ["bag", 0]] self.json_player8 = [["id", 2], [ "species", [[["food", 2], ["body", 2], ["population", 2], ["traits", []]], [["food", 0], ["body", 1], ["population", 1], ["traits", []]]] ], ["bag", 0]] self.json_player9 = [["id", 3], [ "species", [[["food", 0], ["body", 1], ["population", 1], ["traits", []]]] ], ["bag", 0]] self.json_player10 = [["id", 1], [ "species", [[["food", 0], ["body", 5], ["population", 1], ["traits", ["fat-tissue"]], ["fat-food", 5]], [["food", 0], ["body", 6], ["population", 1], ["traits", ["warning-call"]]]] ], ["bag", 0]] self.json_player11 = [["id", 2], [ "species", [[["food", 2], ["body", 2], ["population", 2], ["traits", []]], [["food", 0], ["body", 1], ["population", 1], ["traits", []]]] ], ["bag", 0]] self.json_player12 = [["id", 3], [ "species", [[["food", 0], ["body", 1], ["population", 1], ["traits", []]]] ], ["bag", 0]] self.json_player13 = [["id", 1], [ "species", [[["food", 0], ["body", 3], ["population", 2], ["traits", ["carnivore", "fat-tissue"]], ["fat-food", 3]]] ], ["bag", 0]] self.json_player14 = [["id", 2], [ "species", [[["food", 3], ["body", 3], ["population", 6], ["traits", []]], [["food", 0], ["body", 5], ["population", 4], ["traits", []]]] ], ["bag", 0]] self.json_player15 = [["id", 3], [ "species", [[["food", 2], ["body", 2], ["population", 2], ["traits", []]]] ], ["bag", 0]] self.json_player16 = [["id", 3], ["species", []], ["bag", 0]]
for subShell in core[0]: #print(subShell) coreShells.append(SubShell(subShell[0], subShell[1], subShell[2])) core = Core(coreShells, core[1]) for n in range(core.maxN+1, nMax+1, 1): for L in range(0, nMax, 1): excitedShell = SubShell(n, L, 1) excitedState = ExcitedState(excitedShell) configuration = Configuration(core, excitedState) states.append(configuration) return states nMax = 10 He = species.Species('He') O = species.Species('O') NIST = readNISTSpectra(He) theory = calculateExpectedStates(He, 10) NISTStateIDs = [] for state in NIST: for IDterm in state.ID: NISTStateIDs.append(IDterm) for state in theory: for termID in state.ID: if termID in NISTStateIDs: '''
import plotter import matplotlib.pyplot as plt ############### SORT LEVELS ################## constants = util.Constants() nMax = 20 speciesList = ['C', 'C+', 'N', 'N+', 'N++', 'O', 'O+', 'O++', 'F+', 'F++', 'F+++', 'Ne++', 'Ne+++'] useList = ['O', 'N', 'O+', 'N+'] for useName in useList: use = species.Species(useName) allSpecies = [] for speciesStr in speciesList: speciesObj = species.Species(speciesStr) allSpecies.append([speciesObj, spectra.readNISTSpectra(speciesObj)]) NIST = spectra.readNISTSpectra(use) theory = spectra.calculateExpectedStates(use, nMax) calcEnergy = spectra.CalcEnergy(nMax, use, NIST, theory, allSpecies) completeLevels, calculatedLevels = calcEnergy.populateTheory() calculatedLevels = spectra.sortSpectra(calculatedLevels, None) completeLevels = spectra.sortSpectra(completeLevels, None) NISTSorted = spectra.sortSpectra(NIST, None)
#!/usr/bin/python3 import sys sys.path.append("/home/alacny/Programowanie/Python/Pandemic/lib") import species as h johny=[h.Species(), h.Species(), h.Species(), h.Species(), h.Species(), \ h.Species(), h.Species(), h.Species(), h.Species(), h.Species()] for i in range(0, 10): johny[i].setPOfInf(70) # johny[i].setImmune() johny[i].setInfection() print(johny[i].getIllness())
#Urm = potential(rm, J) #print(J, rm, Urm) warnings.simplefilter('error') try: rm = fsolve(potentialDerivative, re*1.7, args=J) Urm = potential(rm, J) #print(J, rm, Urm) return rm, Urm except RuntimeWarning: return False N2 = species.Species('N2') O2 = species.Species('O2') #print(N2.spectralData['Te']) energyModes = EnergyModes(O2) #asdf = energyModes.vibrational(0) Q = energyModes.getEnergy(300) print(Q) ''' n = 0 v = 3 J = 1
def initlpa(): global zstart0, zpos, xp0, yp0, zp0, wp0, l_moving_window, diagnosticsScript, laser_total_length, Eamp, laser_duration, laser_risetime, laser_waist, laser_amplitude, laser_phase, laser_profile, k0, w0, vg, max_diff_density, max_radius, max_parab_radius, norm_diff_density, betafrm, Lplasma, zstart_plasma, zstart_ions, length_pramp, length_pramp_exit, length_iramp, Lions, length_iramp_exit, dens_ions, dens0, ions, rp0, zstart_laser, em, laser_radius, laser_radius1, live_plot_freq, elec, prot, ions, zstart_laser1, zstart_ions_lab, Tstart_laser1, laser_amplitude1, laser_phase1, laser_profile1, k1, w1, ZR1, laser_total_length1, Eamp1, laser_duration1, laser_risetime1 global bigRun global runDim # --- flags turning off unnecessary diagnostics (ignore for now) warp.top.ifzmmnt = 0 warp.top.itmomnts = 0 warp.top.itplps = 0 warp.top.itplfreq = 0 warp.top.zzmomnts = 0 warp.top.zzplps = 0 warp.top.zzplfreq = 0 warp.top.nhist = warp.top.nt warp.top.iflabwn = 0 warp.w3d.lrhodia3d = False warp.w3d.lgetese3d = False warp.w3d.lgtlchg3d = False #EnableAll() #------------------------------------------------------------------------------- # main parameters #------------------------------------------------------------------------------- if runDim == 3: dim = "3d" else: dim = "2d" dpi = 100 # graphics resolution l_test = 0 # Will open output window on screen # and stop before entering main loop. l_gist = 0 # Turns gist plotting on/off l_restart = False # To restart simulation from an old run (works?) restart_dump = "" # dump file to restart from (works?) l_moving_window = 1 # on/off (Galilean) moving window l_plasma = 1 # on/off plasma l_ions = 1 # on/off plasma ions l_external_field = 1 # on/off external field for the injection pulse l_beam = 0 # on/off electron beam l_injectplane = 1 # on/off beam injection through plane l_usesavedist = 0 # if on, uses dump of beam particles distribution savedist = 'unitdist4sym300000' # beam initial distribution file svstride = 100 # loads only every svstride particles from dump l_smooth = 1 # on/off smoothing of current density l_laser = 1 # on/off laser l_pdump = 0 # on/off regular dump of beam data stencil = 0 # 0 = Yee; 1 = Yee-enlarged (Karkkainen) on EF,B; 2 = Yee-enlarged (Karkkainen) on E,F # use 0 or 1; 2 does not verify Gauss Law if dim == "1d": stencil = 0 # coefficient to multiply default time step that is set at the EM solver CFL if bigRun: dtcoef = 0.25 / 4.0 else: dtcoef = 1.0 warp.top.depos_order = 3 # particles deposition order (1=linear, 2=quadratic, 3=cubic) warp.top.efetch = 4 # field gather type (1=from nodes "momentum conserving"; 4=from Yee mesh "energy conserving") nzstations = 50 # number of beam diag z-stations l_pselect = 0 # on/off selection of particles (i.e. remove halo) for diagnostics warp.top.runid = "lpa_basic" # run name warp.top.pline1 = "basic lpa" # comment line on plots warp.top.runmaker = "J.-L. Vay," # run makers warp.top.lrelativ = True # on/off relativity (for particles push) warp.top.pgroup.lebcancel_pusher = True # flag for particle pusher (0=Boris pusher; 1=Vay PoP 08 pusher) l_verbose = 0 # verbosity level (0=off; 1=on) #------------------------------------------------------------------------------- # diagnostics parameters + a few other settings #------------------------------------------------------------------------------- hist_freq = 50 # frequency (in time steps) of beam history data saving live_plot_freq = 2800 * 2 #2400 # frequency (in time steps) of live plots (off is l_test is off) #------------------------------------------------------------------------------- # boosted frame #------------------------------------------------------------------------------- gammafrm = 1. betafrm = math.sqrt(1. - 1. / gammafrm**2) if gammafrm > 1.: # turns ON plasma ions if in boosted frame l_ions = 1 l_moving_window = 1 #------------------------------------------------------------------------------- # some units for convenience (& clarity) #------------------------------------------------------------------------------- microns = 1.e-6 femtoseconds = 1.e-15 lambda_laser_lab = 5.0 * microns # wavelength lambda_laser_lab1 = 0.4 * microns # wavelength for the second laser #------------------------------------------------------------------------------- # plasma density, length and ramps #------------------------------------------------------------------------------- # --- in lab frame dfact = 1. # coefficient factor for plasma density (for scaled simulations) dens0lab = dfact * 2.0e23 # plasma density (flat section) wplab = math.sqrt(dens0lab * warp.echarge**2 / (warp.eps0 * warp.emass)) # plasma frequency kplab = wplab / warp.clight # plasma wavenumber lambda_plasma_lab = 2. * math.pi / kplab # plasma wavelength length_pramp_lab = 15. * lambda_laser_lab / ( dfact**1.5) #15. # plasma entrance ramp length length_pramp_exit_lab = 15. * lambda_laser_lab / ( dfact**1.5) #15. # plasma exit ramp length Lplasma_lab = 10000. * lambda_laser_lab / dfact**1.5 #500. # plasma total length (including ramps) zstart_plasma_lab = 30. * lambda_laser_lab / dfact**1.5 #40. # --- in boosted frame dens0 = dens0lab * gammafrm # plasma density length_pramp = length_pramp_lab / gammafrm # plasma ramp length length_pramp_exit = length_pramp_exit_lab / gammafrm # plasma ramp length Lplasma = Lplasma_lab / gammafrm # plasma total length zstart_plasma = zstart_plasma_lab / gammafrm # plasma starting point #------------------------------------------------------------------------------- # ions density, length and ramps #------------------------------------------------------------------------------- # --- in lab frame dens_ions_lab = 0.1 * dens0lab # ions density (flat section) length_iramp_lab = 5. * lambda_laser_lab / ( dfact**1.5) #4. # ions entrance ramp length length_iramp_exit_lab = 5. * lambda_laser_lab / ( dfact**1.5) #4. # ions exit ramp length Lions_lab = 20. * lambda_laser_lab / dfact**1.5 #16. # ions total length (including ramps) zstart_ions_lab = 60. * lambda_laser_lab / (dfact**1.5) #80. # --- in boosted frame dens_ions = dens_ions_lab * gammafrm # ions density length_iramp = length_iramp_lab / gammafrm # ions ramp length length_iramp_exit = length_iramp_exit_lab / gammafrm # ions ramp length Lions = Lions_lab / gammafrm # ions total length zstart_ions = zstart_ions_lab / gammafrm # ions starting point #------------------------------------------------------------------------------- # laser parameters #------------------------------------------------------------------------------- # --- in lab frame KP_L = 2.0 # normalized length - standard gaussian form P=P0*numpy.exp(-2xi^2/L^2) KP_SIGMA = 3.02 # normalized transverse spot size - standard gaussian form I=I0*numpy.exp(-2r^2/SIGMA^2) laser_radius = KP_SIGMA / kplab laser_waist = laser_radius * 2.354820 # radius -> FWHM laser_length_lab = 4.75 * lambda_laser_lab #4.75 # laser length laser_duration_lab = laser_length_lab / warp.clight # laser duration laser_risetime_lab = 3. * laser_duration_lab # laser_dura_fwhm_lab = 1.1774 * laser_duration_lab laser_polangle = 0 # polarization (0=aligned with x; math.pi/2=aligned with y) a0 = 1.17 # normalized potential vector (amplitude) k0lab = 2. * math.pi / lambda_laser_lab w0lab = k0lab * warp.clight ZR = 0.5 * k0lab * (laser_waist**2) # Rayleigh length zstart_laser_lab = 0. # --- in boosted frame lambda_laser = lambda_laser_lab * gammafrm * (1. + betafrm) # wavelength laser_duration = laser_duration_lab * gammafrm * (1. + betafrm) laser_length = laser_duration / warp.clight laser_risetime = 3. * laser_duration laser_dura_fwhm = 1.1774 * laser_duration zstart_laser = 0. k0 = 2. * math.pi / lambda_laser w0 = k0 * warp.clight Eamp = a0 * w0 * warp.emass * warp.clight / warp.echarge Bamp = Eamp / warp.clight if l_laser == 0: Eamp *= 1.e-15 Bamp *= 1.e-15 #-------------------------add second laser--------------------------------- KP_L1 = 2.0 # normalized length - standard gaussian form P=P0*numpy.exp(-2xi^2/L^2) KP_SIGMA1 = 2. * math.pi / 15. # normalized transverse spot size - standard gaussian form I=I0*numpy.exp(-2r^2/SIGMA^2) laser_radius1 = KP_SIGMA1 / kplab laser_waist1 = laser_radius1 * 2.354820 # radius -> FWHM laser_length_lab1 = 10. * lambda_laser_lab1 # laser length laser_duration_lab1 = laser_length_lab1 / warp.clight # laser duration (FWHM) laser_risetime_lab1 = 3. * laser_duration_lab1 laser_dura_fwhm_lab1 = 1.1774 * laser_duration_lab1 laser_polangle1 = 0 # polarization (0=aligned with x; math.pi/2=aligned with y) a1 = 0.135 # normalized potential vector (amplitude) k1lab = 2. * math.pi / lambda_laser_lab1 w1lab = k1lab * warp.clight ZR1 = 0.5 * k1lab * (laser_waist1**2) # Rayleigh length #zstart_laser_lab1 = (7.6-28.)*lambda_laser_lab # --- in boosted frame lambda_laser1 = lambda_laser_lab1 * gammafrm * (1. + betafrm) # wavelength laser_duration1 = laser_duration_lab1 * gammafrm * (1. + betafrm) laser_length1 = laser_duration1 / warp.clight laser_risetime1 = 3. * laser_duration1 laser_dura_fwhm1 = 1.1774 * laser_duration1 #zstart_laser1 = zstart_laser_lab1/gammafrm k1 = 2. * math.pi / lambda_laser1 w1 = k1 * warp.clight Eamp1 = a1 * w1 * warp.emass * warp.clight / warp.echarge Bamp1 = Eamp1 / warp.clight if l_laser == 0: Eamp1 *= 1.e-15 Bamp1 *= 1.e-15 #------------------------------------------------------------------------------- # plasma cont'd #------------------------------------------------------------------------------- K = k0lab / kplab Ld = LINEAR_DEPHASING = 0.5 * lambda_plasma_lab**3 / lambda_laser_lab**2 # linear dephasing length BETAG_LINEAR_LAB = math.sqrt(1 - (1. / K) * (1. / K)) # linear beta of wake in lab GAMMAG_LINEAR_LAB = 1. / math.sqrt( 1 - BETAG_LINEAR_LAB * BETAG_LINEAR_LAB) # linear gamma of wake in lab BETAG_LINEAR = (BETAG_LINEAR_LAB - betafrm) / ( 1. - BETAG_LINEAR_LAB * betafrm ) # linear beta of wake in simulation frame GAMMAG_LINEAR = 1. / math.sqrt( 1 - BETAG_LINEAR * BETAG_LINEAR) # linear gamma of wake in simulation frame kp = kplab * (gammafrm * (1. - BETAG_LINEAR_LAB * betafrm)) lambda_plasma = 2. * math.pi / kp densc = warp.emass * warp.eps0 * w0lab**2 / warp.echarge**2 # critical density #------------------------------------------------------------------------------- # print some plasma parameters to the screen #------------------------------------------------------------------------------- print("the laser group velocity is: ") print BETAG_LINEAR * warp.clight print("the laser spot size is: ") print laser_waist print("the Rayleigh length is: ") print ZR print("the laser wavelength is: ") print lambda_laser print("the second laser spot size is: ") print laser_waist1 print("the Rayleigh length is: ") print ZR1 print("the laser wavelength is: ") print lambda_laser1 print("the plasma wavelength is: ") print lambda_plasma print("the plasma length is: ") print Lplasma #------------------------------------------------------------------------------- # e-beam #------------------------------------------------------------------------------- # --- in lab frame E_BEAM_GAMMA = GAMMAG_LINEAR_LAB * 1.5 E_BEAM_ENERGY_MEV = 0.511 * (E_BEAM_GAMMA - 1.) E_BEAM_BETA = math.sqrt(1. - 1. / (E_BEAM_GAMMA * E_BEAM_GAMMA)) E_BEAM_U = E_BEAM_GAMMA * E_BEAM_BETA E_BEAM_RADIUS = 0.825e-6 / math.sqrt(dfact) E_BEAM_LENGTH = 0.85e-6 / math.sqrt(dfact) # --- transverse spread (RMS Gaussian) GAMMAVXSIGMA = 0. GAMMAVYSIGMA = 0. # --- longitudinal spread (RMS Gaussian) GAMMAVZSIGMA = 0. E_BEAM_DENSITY_PEAK = 1.0e10 E_BEAM_PHASE = 5. * math.pi / 4. E_BEAM_DISTANCE_BEHIND_LASER = E_BEAM_PHASE / kplab #------------------------------------------------------------------------------- # number of grid cells #------------------------------------------------------------------------------- # --- transverse # --- longitudinal if bigRun: nx = 1200 nzplambda = 60 else: if runDim == 3: nx = 1200 / 12 nzplambda = 60 / 12 else: nx = 1200 / 6 nzplambda = 60 / 6 #------------------------------------------------------------------------------- # number of plasma macro-particles/cell #------------------------------------------------------------------------------- nppcellx = 1 #2 nppcelly = 1 nppcellz = 2 if dim == "2d": nppcelly = 1 if dim == "1d": nppcellx = nppcelly = 1 #------------------------------------------------------------------------------- # grid dimensions, nb cells and BC #------------------------------------------------------------------------------- warp.w3d.xmmax = 3.0 * laser_radius warp.w3d.xmmin = -warp.w3d.xmmax warp.w3d.ymmax = warp.w3d.xmmax warp.w3d.ymmin = -warp.w3d.ymmax warp.w3d.nx = nx warp.w3d.ny = warp.w3d.nx warp.w3d.dy = (warp.w3d.ymmax - warp.w3d.ymmin) / warp.w3d.ny if dim in ["1d"]: warp.w3d.nx = 2 warp.w3d.xmmin = -float(warp.w3d.nx) / 2 warp.w3d.xmmax = float(warp.w3d.nx) / 2 if dim in ["1d", "2d"]: warp.w3d.ny = 2 warp.w3d.ymmin = -float(warp.w3d.ny) / 2 warp.w3d.ymmax = float(warp.w3d.ny) / 2 warp.w3d.zmmin = -3.5 * lambda_plasma warp.w3d.zmmax = 3. * lambda_laser #/nzplambda warp.w3d.nz = int( (warp.w3d.zmmax - warp.w3d.zmmin) * nzplambda / lambda_laser) warp.w3d.dx = (warp.w3d.xmmax - warp.w3d.xmmin) / warp.w3d.nx warp.w3d.dy = (warp.w3d.ymmax - warp.w3d.ymmin) / warp.w3d.ny warp.w3d.dz = (warp.w3d.zmmax - warp.w3d.zmmin) / warp.w3d.nz # --- enforces dx = dz (= dy) in boosted frame if 0: #gammafrm>1: if warp.w3d.dz < warp.w3d.dx: # x (and y) dimensions are rescaled if needed warp.w3d.dx = warp.w3d.dz warp.w3d.nx = 2 * warp.nint( 0.5 * (warp.w3d.xmmax - warp.w3d.xmmin) / warp.w3d.dx) warp.w3d.xmmax = warp.w3d.nx * warp.w3d.dx / 2 warp.w3d.xmmin = -warp.w3d.xmmax if dim == '3d': warp.w3d.dy = warp.w3d.dz warp.w3d.ny = 2 * warp.nint( 0.5 * (warp.w3d.ymmax - warp.w3d.ymmin) / warp.w3d.dy) warp.w3d.ymmax = warp.w3d.ny * warp.w3d.dy / 2 warp.w3d.ymmin = -warp.w3d.ymmax elif warp.w3d.dx < warp.w3d.dz: # z dimensions are rescaled if needed warp.w3d.dz = warp.w3d.dx warp.w3d.nz = warp.nint( (warp.w3d.zmmax - warp.w3d.zmmin) / warp.w3d.dz) warp.w3d.zmmax = warp.w3d.zmmin + warp.w3d.nz * warp.w3d.dz if gammafrm > 10.: if dim == "1d": dt0 = warp.w3d.dz / warp.clight if dim == "2d": dt0 = 1. / (warp.clight * math.sqrt(1. / warp.w3d.dx**2 + 1. / warp.w3d.dz**2)) if dim == "3d": dt0 = 1. / (warp.clight * math.sqrt(1. / warp.w3d.dx**2 + 1. / warp.w3d.dy**2 + 1. / warp.w3d.dz**2)) mydt = warp.w3d.dz / (math.sqrt(2.) * warp.clight) dtcoef = min(1., mydt / dt0) # --- sets field boundary conditions warp.w3d.bound0 = warp.w3d.boundnz = warp.openbc #warp.w3d.bound0 = warp.w3d.boundnz = -1 # reflective longitudinal BC warp.w3d.boundxy = warp.periodic #-1 # reflective transverse BC # --- sets particles boundary conditions warp.top.pboundxy = warp.periodic #reflect#absorb warp.top.pbound0 = warp.absorb warp.top.pboundnz = warp.absorb if dim == "1d": warp.w3d.boundxy = warp.periodic warp.top.pboundxy = warp.periodic #------------------------------------------------------------------------------- # Plasma channel #------------------------------------------------------------------------------- # Matched spot size in channel (a0) # Note - to decrease channel dN at SIGMA, make matchspot > SIGMA # then dN/dN_matched = (SIGMA^4/matchspot^4), e.g. 5.7% increase in matchspot -> 20% detuning of dN # tor: matchspot/sigma = (dN_matched/dN)^0.25 channel_region = 3.0 * laser_radius CHANNELFAC = 0.4 # factor by which density rise is less than matched density (to compensate self guide) matchspot = laser_radius * (1 / CHANNELFAC)**0.25 # channel max_parab_radius = 0.8 * channel_region max_radius = 0.96 * channel_region diff_density = gammafrm * 1.13e14 / ( matchspot**4 ) #formula for the channel density without the radius squared term if dim == "1d": diff_density = 0. norm_diff_density = diff_density / dens0 #the normalized channel density without the radius squared term max_diff_density = norm_diff_density * ( max_parab_radius**2) #the maximum normalized channel density #------------------------------------------------------------------------------- # set max time #------------------------------------------------------------------------------- tmaxlab = (Lplasma_lab) / warp.clight tmax = tmaxlab / gammafrm #------------------------------------------------------------------------------- # dump/plots intervals (in pico-seconds) #------------------------------------------------------------------------------- dump_intervals = tmax / 20 beamdump_intervals = tmax / 10 plot_intervals = tmax / 10 #------------------------------------------------------------------------------- # set particles #------------------------------------------------------------------------------- weight = 1. * dens0 * warp.w3d.dx * warp.w3d.dy * warp.w3d.dz / ( nppcellx * nppcelly * nppcellz) # weight of plasma macro-particles weightbeam = 0. # needs to be fixed # --- create plasma electron species elec = species.Species(type=species.Electron, weight=weight) # --- create plasma electron species prot = species.Species(type=species.Proton, weight=weight) # --- create e- beam species if l_beam: beam = species.Species(type=species.Electron, weight=weightbeam) # --- create plasma ion species # --- in this example, initial charge state is +5 # --- charge states +6 and +7 are also considered ielec = species.Species(type=species.Electron, weight=weight) if l_ions: nions = 2 ions = [] for i in range(nions): ions.append( species.Species(type=species.Krypton, charge_state=i + 8, weight=weight, name='ions %g' % i)) warp.top.pgroup.ndts = warp.nint(1. / dtcoef) ielec.ndts = 1 #warp.top.pgroup.sm*=1000000 # ions.sm*=1.e20 # to give virtually infinite mass to ions warp.top.wpid = warp.nextpid( ) # creates data space for variable weights (needed for plasma ramps) if runDim == 3: warp.top.xbirthpid = warp.nextpid() warp.top.ybirthpid = warp.nextpid() warp.top.zbirthpid = warp.nextpid() warp.top.uxbirthpid = warp.nextpid() warp.top.uybirthpid = warp.nextpid() warp.top.uzbirthpid = warp.nextpid() warp.top.depos_order[...] = warp.top.depos_order[ 0, 0] # sets deposition order of all species = those of species 0 warp.top.efetch[...] = warp.top.efetch[0] # same for field gathering if dim in ["1d", "2d"]: warp.top.depos_order[1, :] = 1 if dim == "1d": warp.top.depos_order[0, :] = 1 #------------------------------------------------------------------------------- # set smoothing of current density #------------------------------------------------------------------------------- if l_smooth: # --- 1 time nilinear (0.25,0.5,0.25) + 1 time relocalization (-1, 3/2,-1.) npass_smooth = [[1, 1], [0, 0], [4, 1]] alpha_smooth = [[0.5, 3. / 2], [0.5, 3.], [0.5, 3. / 1]] stride_smooth = [[1, 1], [1, 1], [1, 1]] if dim == '1d': for i in range(len(npass_smooth[0])): npass_smooth[0][i] = 0 if dim in ['1d', '2d']: for i in range(len(npass_smooth[0])): npass_smooth[1][i] = 0 else: npass_smooth = [[0], [0], [0]] alpha_smooth = [[1.], [1.], [1.]] stride_smooth = [[1], [1], [1]] #------------------------------------------------------------------------------- # initializes WARP #------------------------------------------------------------------------------- warp.top.fstype = -1 # sets field solver to None (desactivates electrostatic solver) warp.package('w3d') warp.generate() #------------------------------------------------------------------------------- # set a few shortcuts #------------------------------------------------------------------------------- pg = warp.top.pgroup #------------------------------------------------------------------------------- # sets tunnel ionizations #------------------------------------------------------------------------------- tunnel_ioniz = tunnel_ionization.TunnelIonization(stride=1) for i in range(len(ions) - 1): # --- For each ionization level, add tunnel ionization event by registering # --- incident and emitted species. tunnel_ioniz.add(incident_species=ions[i], emitted_species=[ions[i + 1], ielec]) #------------------------------------------------------------------------------- # set input plasma density arrays #------------------------------------------------------------------------------- # --- set intial positions and weights zpos = zstart0 = 0. nppcell = nppcellx * nppcelly * nppcellz dx = warp.w3d.dx / nppcellx dy = warp.w3d.dy / nppcelly dz = warp.w3d.dz / nppcellz nx = nppcellx * warp.w3d.nx ny = nppcelly * warp.w3d.ny nz = nppcellz if dim in ["1d", "2d"]: if dim == "1d": nx = 1 xp0, zp0 = warp.getmesh2d(0., dx, 0, dz / 2, dz, nz - 1) yp0 = xp0 * 0. else: xp0, zp0 = warp.getmesh2d(warp.w3d.xmmin + dx / 2, dx, nx - 1, -warp.w3d.dz + dz / 2, dz, nz - 1) yp0 = xp0 * 0. else: xp0, yp0, zp0 = warp.getmesh3d(warp.w3d.xmmin + dx / 2, dx, nx - 1, warp.w3d.ymmin + dy / 2, dy, ny - 1, -warp.w3d.dz + dz / 2, dz, nz - 1) zp0 -= warp.minnd(zp0) # ensures that zp0 starts at 0 # --- transform to 1D arrays xp0 = xp0.flatten() yp0 = yp0.flatten() zp0 = zp0.flatten() # --- select particles within computational box of local processor ii=warp.compress((xp0>=warp.w3d.xmminlocal) & (xp0<warp.w3d.xmmaxlocal) & \ (yp0>=warp.w3d.ymminlocal) & (yp0<warp.w3d.ymmaxlocal),numpy.arange(len(xp0))) xp0 = warp.take(xp0, ii) yp0 = warp.take(yp0, ii) zp0 = warp.take(zp0, ii) # --- select particles within max_radius rp0 = numpy.sqrt(xp0**2 + yp0**2) ii = warp.compress(rp0 <= max_radius, numpy.arange(len(rp0))) xp0 = warp.take(xp0, ii) yp0 = warp.take(yp0, ii) zp0 = warp.take(zp0, ii) rp0 = numpy.sqrt(xp0**2 + yp0**2) # --- set the transverse profile wp0 = plasma_trans_profile(rp0) if l_plasma: warp.installuserinjection(loadplasma) #------------------------------------------------------------------------------- # set laser pulse numpy.shape #------------------------------------------------------------------------------- #------------------------------------------------------------------------------- # set laser amplitude by combining the pulse numpy.shape, laser profile, and laser phase #------------------------------------------------------------------------------- #------------------------------ add second laser--------------------------------#----------------set the time delay between two lasers-------------------------- T_generate_laser = laser_risetime - laser_risetime1 #2*laser_dura_fwhm # time for generate laser pulses Tstart_laser1 = T_generate_laser zstart_laser1 = zstart_laser - 21.25 * lambda_laser vg = math.sqrt(1 - kplab * kplab / k1lab / k1lab) * warp.clight #------------------------------------------------------------------------------- # initializes main field solver block #------------------------------------------------------------------------------- laser_func_dict = {} laser_func_dict[0] = laser_func if not l_external_field: laser_func_dict[1] = laser_func1 em = warp.EM3D( laser_func=laser_func_dict, # laser_func=laser_func, laser_source_z=0., laser_source_v=-betafrm * warp.clight, laser_polangle=laser_polangle, laser_mode=2, laser_emax=10 * Eamp, stencil=stencil, npass_smooth=npass_smooth, alpha_smooth=alpha_smooth, stride_smooth=stride_smooth, l_2dxz=dim == "2d", l_1dz=dim == "1d", dtcoef=dtcoef, # l_enableovercycle=True, l_verbose=l_verbose) if l_external_field: warp.installothereuser(add_external_laser) #------------------------------------------------------------------------------- # restarts from dump file #------------------------------------------------------------------------------- if l_restart: restore(dump_file) #------------------------------------------------------------------------------- # intializes e- beam #------------------------------------------------------------------------------- if l_beam: # --- add beam particles np_beam = 4000 warp.top.vbeam = E_BEAM_BETA * warp.clight if me == 0: # --- do only if processor 0 if np_beam == 1: # --- loads single test electron beam.addpart(x=array([0.]), y=array([0.]), z=array([0.]), vx=array([0.]), vy=array([0.]), vz=array( [E_BEAM_GAMMA * E_BEAM_BETA * warp.clight]), gi=array([1. / E_BEAM_GAMMA]), lmomentum=True, lallindomain=True) else: # --- loads e- beam if l_usesavedist: # --- loads distribution from file try: ff = PR.PR(savedist + '.pdb') except: ff = PR.PR(savedist + '.pyp') ux = ff.xp[::svstride] * GAMMAVXSIGMA uy = ff.yp[::svstride] * GAMMAVYSIGMA uz = ff.dp[:: svstride] * GAMMAVZSIGMA + E_BEAM_GAMMA * E_BEAM_BETA * warp.clight gi = 1. / math.sqrt(1. + (ux**2 + uy**2 + uz**2) / warp.clight**2) beam.addpart(ff.x[::svstride] * E_BEAM_RADIUS * 2, ff.y[::svstride] * E_BEAM_RADIUS * 2, ff.z[::svstride] * E_BEAM_LENGTH, ux, uy, uz, gi=gi, lmomentum=True, lallindomain=True) else: # --- loads gaussian electron beam beam.add_gaussian_dist(np=np_beam, deltax=E_BEAM_RADIUS * 2 * 1, deltay=E_BEAM_RADIUS * 2 * 1, deltaz=E_BEAM_LENGTH, vthx=GAMMAVXSIGMA * 1, vthy=GAMMAVYSIGMA * 1, vthz=GAMMAVZSIGMA, zmean=0., vzmean=E_BEAM_GAMMA * E_BEAM_BETA * warp.clight, lmomentum=True, lallindomain=True, zdist='regular') np_beam = beam.getn() # --- sets e- beam macro-particles weight if dim == "1d": beam.sw = (E_BEAM_DENSITY_PEAK * ((E_BEAM_RADIUS * 2) * warp.w3d.dx * warp.w3d.dy * E_BEAM_LENGTH * (2. * math.pi))) / np_beam if dim == "2d": beam.sw = (E_BEAM_DENSITY_PEAK * ((E_BEAM_RADIUS * 2) * warp.w3d.dy * E_BEAM_LENGTH * (2. * math.pi))) / np_beam if dim == "3d": beam.sw = (E_BEAM_DENSITY_PEAK * ((E_BEAM_RADIUS * 2)**2 * E_BEAM_LENGTH * (2. * math.pi) * 1.5)) / np_beam # --- install e- beam diagnostic routine if sum(pg.nps) > 0: # --- set beam position in lab frame pg.zp += zstart0 - E_BEAM_DISTANCE_BEHIND_LASER - 0.5 * laser_total_length_lab # --- transform particle positions and velocity to boosted frame bf = Boosted_Frame(gammafrm, l_setselfb=0) zinit = getz().copy() bf.boost(beam, l_inject_plane=l_injectplane, lallindomain=1, l_rmzmean=0, zinject=-5. * warp.w3d.dz) particleboundaries3d(warp.top.pgroup, -1, False) #------------------------------------------------------------------------------- # register solver #------------------------------------------------------------------------------- print 'register solver' warp.registersolver(em) if runDim == 3: em.finalize() print warp.getregisteredsolver().dict_of_grids #------------------------------------------------------------------------------- # sets moving window velocity #------------------------------------------------------------------------------- if l_moving_window: #warp.top.vbeamfrm=BETAG_LINEAR*warp.clight warp.top.vbeamfrm = warp.clight #------------------------------------------------------------------------------- # set a few shortcuts #------------------------------------------------------------------------------- #el=elec #f = em.fields #bhist=numpy.ones([nions,warp.w3d.nz+1]) #bhist[1:,:]=0. #def accuhist(): # global bhist # for i in range(nions-2,-1,-1): # Ex = em.gatherex() # Ey = em.gatherey() # if me==0: # E = math.sqrt(Ex*Ex+Ey*Ey) # E0 = numpy.where(E<=1.e-10*Eamp,1.e-10*Eamp,E) # dn = numpy.where(E==0.,0.,top.dt*tunnel_ioniz.GetADKrateSI(abs(E0),i+8,ions[i].type,top.dt)) # bhist[i+1,:]+=dn*bhist[i] # bhist[i,:]-=dn*bhist[i] #installafterstep(accuhist) #window(1,hcp='lineout.cgm',dump=1,display='') #window(2,hcp='Ex.cgm',dump=1,display='') #if enableWarpLivePlots : # installafterstep(liveplots) # make it visible to visit warp.listofallspecies = species.listofallspecies # add filtered species for ionized electrons # for now it should be at index 2... iElec = warp.listofallspecies[2] iElecCore = WarpVisItSpeciesFilters.CreateFilteredSpecies( iElec, 'HaloFilter', 'halo') warp.listofallspecies.append(iElecCore) # print species i = 0 for s in warp.listofallspecies: print 'species %d %s %s' % (i, s.type.name, str(s.name)) i += 1 if (len(warp.listofallspecies) < 1): raise RuntimeError('no particle species!') return
sys.path.append("/home/alacny/Programowanie/Python/Pandemic/lib") import species as h import world as w # Initial number of persons maxP=100 # Range of infection rInf=10 # Max time of the simulation tMax = 10000 # Creating persons person=[] for i in range(0,maxP): person.append(h.Species()) # Initial infection person[0].raiseInfection(1) person[0].goToXY(0,0) outF = open("pandemic.out","w") outNInf = open("infected.out","w") # Number of infected species nInf=1 # Main loop for t in range(0,tMax): # Moving persons x=list() y=list()
def AddToReaction(name, reaction): reaction.append(species.Species(name))
import util import species import matplotlib.pyplot as plt ############### SORT LEVELS ################## constants = util.Constants() nMax = 30 speciesList = ['O', 'O+', 'F+', 'Ne++'] allSpecies = [] for speciesStr in speciesList: speciesObj = species.Species(speciesStr) allSpecies.append([speciesObj, spectra.readNISTSpectra(speciesObj)]) O = species.Species('O') use = O NIST = spectra.readNISTSpectra(use) theory = spectra.calculateExpectedStates(use, nMax) calcEnergy = spectra.CalcEnergy(nMax, use, NIST, theory, allSpecies) completeLevels, calculatedLevels = calcEnergy.populateTheory() calculatedLevels = spectra.sortSpectra(calculatedLevels, 'calculated') completeLevels = spectra.sortSpectra(completeLevels, 'complete')
def generate_Species(obj): if isinstance(obj, parseobj.AnyCallable): obj = obj._as_ParseObj() if isinstance(obj, parseobj.ParseObj): sp = species.Species() for elem in obj._elements(): su = species.Subunit(elem.name) if elem.args is not None: for mod in elem.args: if is_parseobj(mod) and mod._size() == 1: arg = mod._elements()[0] name, binding = arg.name, arg.modification if binding is None: su.add_modification(name, "", "") else: binding = str(binding) if not (binding.isdigit() or binding == "" or binding[0] == "_"): raise RuntimeError, ( "invalid binding [%s] given." % (binding)) su.add_modification(name, "", binding) elif (isinstance(mod, parseobj.InvExp) and is_parseobj(mod._target()) and mod._target()._size() == 1): arg = mod._target()._elements()[0] name, binding = arg.name, arg.modification if binding is not None: raise RuntimeError, ( "invalid binding [%s] given." % (binding)) su.add_exclusion(name) elif isinstance(mod, tuple): if any([not isinstance(dom, parseobj.AnyCallable) for dom in mod]): raise RuntimeError, ( "invalid commutative definition [%s] found" % (str(mod))) doms = [dom._elements()[0].name for dom in mod] su.set_commutative(doms) else: raise RuntimeError, ( "invalid argument [%s] found." % str(mod)) if elem.kwargs is not None: for name, value in elem.kwargs.items(): if is_parseobj(value) and value._size() == 1: arg = value._elements()[0] state, binding = str(arg.name), arg.modification if binding is None: su.add_modification(name, state, "") else: binding = str(binding) if not (binding.isdigit() or binding == "" or binding[0] == "_"): raise RuntimeError, ( "invalid binding [%s] given." % (binding)) su.add_modification(name, state, binding) elif ((isinstance(value, list) or isinstance(value, tuple)) and all([is_parseobj(dom) and dom._size() == 1 for dom in value])): doms = tuple(dom._elements()[0].name for dom in value) su.add_domain_class(name, doms) if isinstance(value, tuple): su.set_commutative(doms) else: raise RuntimeError, ( "invalid argument [%s] found." % str(value)) sp.add_subunit(su) return (sp, ) elif isinstance(obj, parseobj.InvExp): return (None, ) elif isinstance(obj, parseobj.AddExp): subobjs = obj._elements() return tuple(generate_Species(subobj)[0] for subobj in subobjs) raise RuntimeError, 'invalid expression; "%s" given' % str(obj)
def setUp(self): self.spec = species.Species(0, 1, 1, [])