def writeStatLats(self, s, bunch, lattlength=0): self.bunchtwissanalysis.analyzeBunch(bunch) emitx = self.bunchtwissanalysis.getEmittance(0) betax = self.bunchtwissanalysis.getBeta(0) alphax = self.bunchtwissanalysis.getAlpha(0) betay = self.bunchtwissanalysis.getBeta(1) alphay = self.bunchtwissanalysis.getAlpha(1) emity = self.bunchtwissanalysis.getEmittance(1) dispersionx = self.bunchtwissanalysis.getDispersion(0) ddispersionx = self.bunchtwissanalysis.getDispersionDerivative(0) #dispersiony = self.bunchtwissanalysis.getDispersion(1, bunch) #ddispersiony = self.bunchtwissanalysis.getDispersionDerivative(1, bunch) sp = bunch.getSyncParticle() time = sp.time() if lattlength > 0: time = sp.time() / (lattlength / (sp.beta() * speed_of_light)) # if mpi operations are enabled, this section of code will # determine the rank of the present node rank = 0 # default is primary node mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) # only the primary node needs to output the calculated information if (rank == 0): self.file_out.write( str(s) + "\t" + str(time) + "\t" + str(emitx) + "\t" + str(emity) + "\t" + str(betax) + "\t" + str(betay) + "\t" + str(alphax) + "\t" + str(alphay) + "\t" + str(dispersionx) + "\t" + str(ddispersionx) + "\n")
def writeMoments(self, s, bunch, lattlength=0): sp = bunch.getSyncParticle() time = sp.time() if lattlength > 0: time = sp.time() / (lattlength / (sp.beta() * speed_of_light)) self.bunchtwissanalysis.computeBunchMoments(bunch, self.order, self.dispterm, self.emitnormterm) # if mpi operations are enabled, this section of code will # determine the rank of the present node rank = 0 # default is primary node mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) # only the primary node needs to output the calculated information if (rank == 0): self.file_out.write(str(s) + "\t" + str(time) + "\t") for i in range(0, self.order + 1): for j in range(0, i + 1): self.file_out.write( str(self.bunchtwissanalysis.getBunchMoment(i - j, j)) + "\t") self.file_out.write("\n")
def LinearRestoringForce(bunch, force): rank = 0 numprocs = 1 mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) numprocs = orbit_mpi.MPI_Comm_size(comm) nparts_arr_local = [] for i in range(numprocs): nparts_arr_local.append(0) nparts_arr_local[rank] = bunch.getSize() data_type = mpi_datatype.MPI_INT op = mpi_op.MPI_SUM nparts_arr = orbit_mpi.MPI_Allreduce(nparts_arr_local, data_type, op, comm) for i in range(bunch.getSize()): en = bunch.dE(i) en = en + bunch.z(i) * force bunch.dE(i, en) return
def analyzeSignal(self, bunch): self.bunchtwissanalysis.analyzeBunch(bunch) # if mpi operations are enabled, this section of code will # determine the rank of the present node rank = 0 # default is primary node mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) # only the primary node needs to output the calculated information if (rank == 0): self.xAvg = self.bunchtwissanalysis.getAverage(0) self.xpAvg = self.bunchtwissanalysis.getAverage(1) self.yAvg = self.bunchtwissanalysis.getAverage(2) self.ypAvg = self.bunchtwissanalysis.getAverage(3)
def addParticleIdNumbers(b, fixedidnumber=-1, part_ind=0): rank = 0 numprocs = 1 mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) numprocs = orbit_mpi.MPI_Comm_size(comm) nparts_arr_local = [] for i in range(numprocs): nparts_arr_local.append(0) nparts_arr_local[rank] = b.getSize() data_type = mpi_datatype.MPI_INT op = mpi_op.MPI_SUM nparts_arr = orbit_mpi.MPI_Allreduce(nparts_arr_local, data_type, op, comm) if (b.hasPartAttr("ParticleIdNumber") == 0): b.addPartAttr("ParticleIdNumber") if (fixedidnumber >= 0): for i in range(part_ind, b.getSize()): b.partAttrValue("ParticleIdNumber", i, 0, fixedidnumber) else: istart = 0 if (rank == 0): istart = 0 else: for i in range(rank): istart = istart + nparts_arr[i] for i in range(b.getSize()): idnumber = istart + i b.partAttrValue("ParticleIdNumber", i, 0, idnumber)
def addParticles(self): (xmin,xmax,ymin,ymax) = self.injectregion #adjusts number of particles injected according to varying pattern width if self.lDistFunc.name == "JohoLongitudinalPaint": self.lDistFunc.getCoordinates() self.npartsfloat = self.lDistFunc.frac_change*self.npartsfloat self.nparts = int(round(self.npartsfloat)) rank = 0 numprocs = 1 mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if(mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) numprocs = orbit_mpi.MPI_Comm_size(comm) nPartsGlobal = self.bunch.getSizeGlobal() if(self.nmaxmacroparticles > 0): if(nPartsGlobal >= self.nmaxmacroparticles): return #if((nTurnsDone % injectTurnInterval) != 0): #return x_rank0 = [] xp_rank0 = [] y_rank0 = [] yp_rank0 = [] z_rank0 = [] dE_rank0 = [] ninjected_rank0 = 0 x_local = [] xp_local = [] y_local = [] yp_local = [] z_local = [] dE_local = [] ninjectedlocal = 0 if(rank == 0): for i in xrange(int(self.nparts)): (x,px) = self.xDistFunc.getCoordinates() (y,py) = self.yDistFunc.getCoordinates() (z,dE) = self.lDistFunc.getCoordinates() if((x > xmin) & (x < xmax) & (y > ymin) & (y < ymax)): ninjectedlocal = ninjectedlocal + 1 x_rank0.append(x) xp_rank0.append(px) y_rank0.append(y) yp_rank0.append(py) z_rank0.append(z) dE_rank0.append(dE) #self.bunch.addParticle(x,px,y,py,z,dE) else: self.lostbunch.addParticle(x,px,y,py,z,dE) #self.bunch.compress() ninjected = orbit_mpi.MPI_Bcast(ninjectedlocal, mpi_datatype.MPI_INT, 0, comm) x_local = orbit_mpi.MPI_Bcast(x_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) xp_local = orbit_mpi.MPI_Bcast(xp_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) y_local = orbit_mpi.MPI_Bcast(y_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) yp_local = orbit_mpi.MPI_Bcast(yp_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) z_local = orbit_mpi.MPI_Bcast(z_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) dE_local = orbit_mpi.MPI_Bcast(dE_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) n_remainder = ninjected % numprocs; n_inj_local = ninjected/numprocs; #inject the equal number of particles on each CPU i_start = rank * n_inj_local i_stop = (rank+1) * n_inj_local for i in xrange(i_start, i_stop): self.bunch.addParticle(x_local[i],xp_local[i],y_local[i],yp_local[i],z_local[i],dE_local[i]) n_max_index = numprocs * n_inj_local for i in xrange (n_remainder - 1): i_cpu = int( numprocs * random.random()) orbit_mpi.MPI_Bcast(i_cpu, mpi_datatype.MPI_INT, 0,comm) if(rank == i_cpu): self.bunch.addParticle(x_local[i + 1 + n_max_index], xp_local[i + 1 + n_max_index], y_local[i + 1 + n_max_index], yp_local[i + 1 + n_max_index],z_local[i + 1 + n_max_index], dE_local[i + 1 + n_max_index]) n_inj_local = n_inj_local + 1 #nInjectedMacros += n_inj_local; self.bunch.compress() self.lostbunch.compress()
def addParticles(self): """ Performs injections. """ #---- User can skip injection if self.nparts is zero if (self.nparts == 0): return random.seed(100) (xmin, xmax, ymin, ymax) = self.injectregion #adjusts number of particles injected according to varying pattern width if self.lDistFunc.name == "JohoLongitudinalPaint": self.lDistFunc.getCoordinates() self.npartsfloat = self.lDistFunc.frac_change * self.npartsfloat self.nparts = int(round(self.npartsfloat)) rank = 0 numprocs = 1 mpi_init = orbit_mpi.MPI_Initialized() comm = orbit_mpi.mpi_comm.MPI_COMM_WORLD if (mpi_init): rank = orbit_mpi.MPI_Comm_rank(comm) numprocs = orbit_mpi.MPI_Comm_size(comm) nPartsGlobal = self.bunch.getSizeGlobal() if (self.nmaxmacroparticles > 0): if (nPartsGlobal >= self.nmaxmacroparticles): return x_rank0 = [] xp_rank0 = [] y_rank0 = [] yp_rank0 = [] z_rank0 = [] dE_rank0 = [] ninjected_rank0 = 0 x_local = [] xp_local = [] y_local = [] yp_local = [] z_local = [] dE_local = [] ninjectedlocal = 0 if (rank == 0): for i in range(int(self.nparts)): (x, px) = self.xDistFunc.getCoordinates() (y, py) = self.yDistFunc.getCoordinates() (z, dE) = self.lDistFunc.getCoordinates() if ((x > xmin) & (x < xmax) & (y > ymin) & (y < ymax)): ninjectedlocal = ninjectedlocal + 1 x_rank0.append(x) xp_rank0.append(px) y_rank0.append(y) yp_rank0.append(py) z_rank0.append(z) dE_rank0.append(dE) else: self.addLostParticle(self.bunch, self.lostbunch, x, px, y, py, z, dE) nPartsLostGlobal = self.lostbunch.getSizeGlobal() nPartsTotalGlobal = nPartsGlobal + nPartsLostGlobal ninjected = orbit_mpi.MPI_Bcast(ninjectedlocal, mpi_datatype.MPI_INT, 0, comm) x_local = orbit_mpi.MPI_Bcast(x_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) xp_local = orbit_mpi.MPI_Bcast(xp_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) y_local = orbit_mpi.MPI_Bcast(y_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) yp_local = orbit_mpi.MPI_Bcast(yp_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) z_local = orbit_mpi.MPI_Bcast(z_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) dE_local = orbit_mpi.MPI_Bcast(dE_rank0, mpi_datatype.MPI_DOUBLE, 0, comm) n_remainder = ninjected % numprocs n_inj_local = ninjected / numprocs #---- inject the equal number of particles on each CPU i_start = rank * n_inj_local i_stop = (rank + 1) * n_inj_local for i in range(i_start, i_stop): particleId = nPartsTotalGlobal + i self.addInjectedParticle(self.bunch, x_local[i], xp_local[i], y_local[i], yp_local[i], z_local[i], dE_local[i], particleId) #---- inject the reminder of the particles n_max_index = numprocs * n_inj_local nPartsGlobal = self.bunch.getSizeGlobal() nPartsLostGlobal = self.lostbunch.getSizeGlobal() nPartsTotalGlobal = nPartsGlobal + nPartsLostGlobal for i in range(n_remainder): i_cpu = random.randint(0, numprocs - 1) i_cpu = orbit_mpi.MPI_Bcast(i_cpu, mpi_datatype.MPI_INT, 0, comm) if (rank == i_cpu): particleId = nPartsTotalGlobal + i self.addInjectedParticle(self.bunch, x_local[i + n_max_index], xp_local[i + n_max_index], y_local[i + n_max_index], yp_local[i + n_max_index], z_local[i + n_max_index], dE_local[i + n_max_index], particleId) #---- here n_inj_local is just for information for debugging n_inj_local = n_inj_local + 1 self.bunch.compress() self.lostbunch.compress()
# MPI_Wtick() # finalize([message]) #------------------------------------------------------ # and MPI constants: # MPI_IDENT # MPI_CONGRUENT # MPI_SIMILAR # MPI_UNEQUAL # MPI_UNDEFINED # MPI_UNDEFINED_RANK # MPI_SUCCESS # MPI_ANY_SOURCE # MPI_ANY_TAG #------------------------------------------------------ mpi_init = orbit_mpi.MPI_Initialized() cpu = orbit_mpi.MPI_Get_processor_name() rank = orbit_mpi.MPI_Comm_rank(orbit_mpi.mpi_comm.MPI_COMM_WORLD) size = orbit_mpi.MPI_Comm_size(orbit_mpi.mpi_comm.MPI_COMM_WORLD) t = orbit_mpi.MPI_Wtime() tick = orbit_mpi.MPI_Wtick() #---------MPI Constant ----------------------- if (rank == 0): print "init=", mpi_init, " rank=", rank, " size=", size, " name=", cpu, " time=", t, " tick=", tick print "MPI_IDENT=", orbit_mpi.MPI_IDENT print "MPI_CONGRUENT=", orbit_mpi.MPI_CONGRUENT print "MPI_SIMILAR=", orbit_mpi.MPI_SIMILAR print "MPI_UNEQUAL=", orbit_mpi.MPI_UNEQUAL print "MPI_UNDEFINED=", orbit_mpi.MPI_UNDEFINED