def computeCollisions(alpha, N, rem, dt, rv_max, vel): # First we have to determine the maximum number of candidate collisions n_cols_max = (N * rv_max * dt / 2) + rem # Remaining collisions (<1) (to be computed in next time_step) rem = n_cols_max - int(n_cols_max) # We only use the integer part n_cols_max = int(n_cols_max) # It is more efficient to generate all random numbers at once random_intel.seed(brng='MT2203') # We choose multiple (n_cols_max) random pairs of particles random_pairs = random_intel.choice(N, size=(n_cols_max, 2)) # List of random numbers to use as collision criteria random_numbers = random_intel.uniform(0, 1, n_cols_max) # Now, we generate random directions, (modulus 1) sigmas costheta = random_intel.uniform(0, 2, size=n_cols_max) - 1 sintheta = np.sqrt(1 - costheta**2) phis = random_intel.uniform(0, 2 * np.pi, size=n_cols_max) x_coord = sintheta * np.cos(phis) y_coord = sintheta * np.sin(phis) z_coord = costheta sigmas = np.stack((x_coord, y_coord, z_coord), axis=1) # This is a vectorized method, it should be faster than the for loop # Using those random pairs we calculate relative velocities rel_vs = np.array( list( map(lambda i, j: vel[i] - vel[j], random_pairs[:, 0], random_pairs[:, 1]))) # And now its modulus by performing a dot product with sigmas array rel_vs_mod = np.sum(rel_vs * sigmas, axis=1) # With this information we can check which collisions are valid ratios = rel_vs_mod / rv_max valid_cols = ratios > random_numbers # The valid pairs of particles of each valid collision are: valid_pairs = random_pairs[valid_cols] # Number of collisions that take place in this step cols_current_step = len(valid_pairs) # Now, we select only those rows that correspond to valid collisions valid_dotProducts = rel_vs_mod[valid_cols] # See: https://stackoverflow.com/questions/16229823/how-to-multiply-numpy-2d-array-with-numpy-1d-array valid_vectors = sigmas[valid_cols] * valid_dotProducts[:, None] new_vel_components = 0.5 * (1 + alpha) * valid_vectors valid_is = valid_pairs[:, 0] valid_js = valid_pairs[:, 1] # Updating the velocities array with its new values vel[valid_is] -= new_vel_components vel[valid_js] += new_vel_components return vel, cols_current_step, rem
def gen_rand_data(nopt, dtype=np.float64): rnd.seed(SEED) return ( rnd.uniform(S0L, S0H, nopt).astype(dtype), rnd.uniform(XL, XH, nopt).astype(dtype), #np.linspace(S0L, S0H, nopt).astype(dtype), #np.linspace(XL, XH, nopt).astype(dtype), rnd.uniform(TL, TH, nopt).astype(dtype), )
def gen_rand_data(nopt, dims=2, NUMBER_OF_CENTROIDS=10, dtype=np.float64): rnd.seed(SEED) return ( rnd.uniform(XL, XH, (nopt, dims)).astype(dtype), np.ones(nopt, dtype=np.int32), np.ones((NUMBER_OF_CENTROIDS, 2), dtype=dtype), np.ones((NUMBER_OF_CENTROIDS, 2), dtype=dtype), np.ones(NUMBER_OF_CENTROIDS, dtype=np.int32), )
# Using Intel's Math Kernel Library # https://software.intel.com/en-us/blogs/2016/06/15/faster-random-number-generation-in-intel-distribution-for-python # 'MCG31' gives the best performance, 'MT2203' provides better randomness # https://software.intel.com/en-us/mkl-vsnotes-basic-generators random_intel.seed(brng='MT2203') results = [] for alpha in (0.35, 0.45, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 0.97, 0.99): a2_mean = [] # Loop for each run of the same alpha for c in range(n_runs): # Initialize particle positions as a 2D numpy array (uniform). # As this is DSMC, some particles may be overlapping and not affect the outcome pos = random_intel.uniform(effective_radius, LX - effective_radius, (N, 3)) # Initialize particle velocities as a 2D numpy array (normal/gaussian). vel = random_intel.normal(0, baseStateVelocity, (N, 3)) # We now scale the velocity so that the vel of the center of mass # is initialized at 0. Pöschel pag.203 vel -= np.mean(vel, axis=0) print() print('Number of particles: ', N) print('Time step: ', dt) print('Coefficient of restitution: ', alpha) print() temperatures = [] cumulants = [] n_collisions = 0
def gen_data(nopt): return ( rnd.uniform(S0L, S0H, nopt), rnd.uniform(XL, XH, nopt), rnd.uniform(TL, TH, nopt), )
def bit_flip(x, prob=0.05): x = np.array(x) selection = rng.uniform(0, 1, x.shape) < prob x[selection] = 1 * np.logical_not(x[selection]) return x
epoch_lossG = 0 epoch_lossD = 0 for i in range(num_batches): print 'Doing batch [{}/{}]'.format(i, num_batches) noise = rng.normal(0, 1, (batch_size, latent_size)) image_batch = X_train[i * batch_size:(i + 1) * batch_size] energy_batch = Y_train[i * batch_size:(i + 1) * batch_size].flatten() ecal_batch = ecal_train[i * batch_size:(i + 1) * batch_size] # num_nodes = len([n.name for n in tf.get_default_graph().as_graph_def().node]) # print("Number of nodes in graph = {}".format(num_nodes)) if image_batch.shape[0] > 0: sampled_energies = rng.uniform(.1, 5, size=(batch_size, 1)) generator_ip = np.multiply(sampled_energies, noise) ecal_ip = np.multiply(2, sampled_energies) generated = sess.run(fake_images, feed_dict={z: generator_ip}) (_, disc_loss) = sess.run( [D_trainer, D_loss_summary], feed_dict={ real_images: image_batch, fake_images: generated, z: generator_ip, flipped_bits_ones: bit_flip(np.ones(batch_size)), energy_batch_ph: energy_batch, ecal_batch_ph: ecal_batch, flipped_bits_zeroes: bit_flip(np.zeros(batch_size)),