def run(n, base_filename, l=0.5): # domain domain = ConvexPolyhedraAssembly() domain.add_box([0, 0], [1, 1]) # initial positions, weights and masses positions = [] if n == 1: radius = 0.3 mass = 3.14159 * radius**2 positions.append([0.5, radius]) else: radius = l / (2 * (n - 1)) mass = l**2 / n**2 for y in np.linspace(radius, l - radius, n): for x in np.linspace(0.5 - l / 2 + radius, 0.5 + l / 2 - radius, n): nx = x + 0.0 * radius * (np.random.rand() - 0.5) ny = y + 0.0 * radius * (np.random.rand() - 0.5) + 0.5 * radius positions.append([nx, ny]) positions = np.array(positions) nb_diracs = positions.shape[0] # dim = positions.shape[ 1 ] # OptimalTransport ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_masses(np.ones(nb_diracs) * mass) ot.set_positions(positions) ot.max_iter = 100 ot.adjust_weights() ot.display_vtk(base_filename + "0.vtk", points=True, centroids=True) # history of centroids ce = ot.get_centroids() ce[:, 1] += radius / 10 bh = [ce] dt = 1.0 for num_iter in range(200): print("num_iter", num_iter) bh.append(ot.get_centroids()) fit_positions(ot, bh, dt) # display n1 = int(num_iter / 1) + 1 ot.display_vtk(base_filename + "{}.vtk".format(n1), points=True, centroids=True)
def run(n, base_filename, l=0.5): # domain domain = ConvexPolyhedraAssembly() domain.add_box([0, 0], [1, 1]) # initial positions, weights and masses positions = [] if n == 1: radius = 0.3 mass = 3.14159 * radius**2 positions.append([0.5, radius]) else: radius = l / (2 * (n - 1)) mass = l**2 / n**2 for y in np.linspace(radius, l - radius, n): for x in np.linspace(radius, l - radius, n): nx = x # + 0.2 * radius * (np.random.rand() - 0.5) ny = y # + 0.2 * radius * (np.random.rand() - 0.5) positions.append([nx, ny]) positions = np.array(positions) nb_diracs = positions.shape[0] dim = positions.shape[1] # OptimalTransport ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_masses(np.ones(nb_diracs) * mass) ot.set_positions(positions) ot.adjust_weights() ot.display_vtk(base_filename + "0.vtk", points=True) g = np.zeros((nb_diracs, dim)) g[:, 1] = -0.001 bh = [ot.get_centroids()] # history of centroids for num_iter in range(50): bh.append(ot.get_centroids()) print("num_iter", num_iter) # proposition for centroids bn = 2 * bh[-1] - bh[-2] + g # find a new set of diracs parameters (position and weight) # to be as close to the new centroids as possible update_positions_to_get_centroids(ot, bn) # display n1 = num_iter + 1 ot.display_vtk(base_filename + "{}.vtk".format(n1), points=True)
def make_case(name, nb_diracs, dim): # default domain if name == "random": positions = np.random.rand(nb_diracs, dim) elif name == "grid": positions = make_grid(nb_diracs, dim) elif name == "grid_with_rand": positions = make_grid(nb_diracs, dim, rand_val=1) elif name == "faces": # voronoi with 100 points pd = PowerDiagram(np.random.rand(5, dim)) # quantization lot = OptimalTransport(positions=make_grid(nb_diracs, dim)) lot.obj_max_dw = 1e-5 lot.verbosity = 1 for ratio in [1 - 0.85**n for n in range(50)]: # density img_size = 1000 img_points = [] items = [range(img_size) for i in range(dim)] for i in itertools.product(*items): img_points.append(i) img = pd.distances_from_boundaries( np.array(img_points) / img_size).reshape((img_size, img_size)) img = (1 - ratio) + ratio * np.exp(-(100 * img)**2) lot.set_domain(ScaledImage([0, 0], [1, 1], img / np.mean(img))) # opt for _ in range(10): lot.adjust_weights() B = lot.get_centroids() lot.set_positions(lot.get_positions() + 0.3 * (B - lot.get_positions())) positions = lot.get_positions() plt.plot(positions[:, 0], positions[:, 1], ".") plt.show() np.save("/data/{}_n{}_d{}_voro.npy".format(name, nb_diracs, dim), (positions[:, 0], positions[:, 1])) # solve if nb_diracs < 32000000: ot = OptimalTransport(positions) # ot.verbosity = 1 # solve ot.adjust_weights() # display # ot.display_vtk( "results/pd.vtk" ) np.save("/data/{}_n{}_d{}.npy".format(name, nb_diracs, dim), (positions[:, 0], positions[:, 1], ot.get_weights()))
ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights( np.ones( positions.shape[ 0 ] ) * target_radius ** 2 ) ot.set_masses( np.ones( positions.shape[ 0 ] ) * np.pi * target_radius ** 2 ) nb_timesteps = int( 20 / target_radius ) for i in range( nb_timesteps ): # change positions weights = ot.get_weights() for n in range( positions.shape[ 0 ] ): c = 1 / ( 10 * weights[ n ] / 7e-4 + 1 ) positions[ n, : ] += c * 0.5 * target_radius * g.grad( positions[ n, : ] ) # optimal weights ot.set_positions( positions ) ot.adjust_weights() # display d = 5 if i % d == 0: ot.display_vtk( directory + "/pd_{:03}.vtk".format( int( i / d ) ) ) # update positions positions = ot.get_centroids() if np.min( positions[ :, 0 ] ) > pos_door: times.append( i ) break print( times )
T = 6.5 nb_timesteps = int( T / timestep ) display_timesteps = np.linspace(0, nb_timesteps-1, 100, dtype = int) ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights( weights ) ot.set_masses( np.ones( positions.shape[ 0 ] ) * np.pi * target_radius ** 2 ) for i in range( nb_timesteps ): print("iteration %d/%d for na=%d" % (i, nb_timesteps,na)) # optimal weights ot.set_positions( positions ) ot.adjust_weights() centroids = ot.get_centroids() # display if i in display_timesteps: print(i) j = display_timesteps.tolist().index(i) ot.display_asy( directory + "/pd_{:03}.asy".format( j ), values=color_values, linewidth=0.0005, dotwidth=target_radius * 0, closing=domain_asy, avoid_bounds=True ) ot.display_vtk( directory + "/pd_{:03}.vtk".format( j ) ) h_positions.append( positions ) h_weights.append( weights ) # update positions descent_direction = np.zeros_like(positions) for n in range( positions.shape[ 0 ] ): descent_direction[n,:] = g.grad( positions[ n, : ], 4 * target_radius )
def run(n, base_filename, l=0.5): # domain domain = ConvexPolyhedraAssembly() # domain.add_box([0, 0], [1, 1]) domain.add_convex_polyhedron([ # x y Nx Ny (ext) [0, 0, -1, -0.2], [0, 0, -0.2, -1], [1, 1, +1, 0], [1, 1, 0, +1], ]) # initial positions, weights and masses positions = [] if n == 1: radius = 0.2 else: radius = l / (2 * (n - 1)) for y in np.linspace(radius, l - radius, n): for x in np.linspace(radius, l - radius, n): nx = x + 0.2 * radius * (np.random.rand() - 0.5) ny = y + 0.2 * radius * (np.random.rand() - 0.5) positions.append([nx, ny]) positions = np.array(positions) nb_diracs = positions.shape[0] # OptimalTransport ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_masses(np.ones(nb_diracs) * l**2 / nb_diracs) ot.set_positions(positions) ot.adjust_weights() ot.display_vtk(base_filename + "0.vtk") ot.set_positions(ot.get_centroids()) velocity = 0.0 * positions for num_iter in range(200): print("num_iter", num_iter) # barycenters at the beginning ot.adjust_weights() b_o = ot.get_centroids() # trial for the new barycenters velocity[:, 0] -= 0.05 * radius * 0.707 velocity[:, 1] -= 0.05 * radius * 0.707 b_n = b_o + velocity # optimisation of positions to go to the target barycenters ropt = scipy.optimize.minimize(obj, b_n.flatten(), (ot, b_n), tol=1e-4, method='BFGS', options={'eps': 1e-4 * radius}) positions = ropt.x.reshape((-1, 2)) ot.set_positions(positions) ot.adjust_weights() # new barycenters, corrected (minimize have update the weights) b_n = ot.get_centroids() velocity = b_n - b_o print(positions, velocity) # display ot.pd.display_vtk_points(base_filename + "pts_{}.vtk".format(num_iter + 1)) ot.display_vtk(base_filename + "{}.vtk".format(num_iter + 1))
min_w = 0 ot = OptimalTransport(domain, RadialFuncEntropy(eps)) ot.set_masses(np.ones(positions.shape[0])) weights = np.zeros(positions.shape[0]) for i in range(101): # optimal weights ot.set_positions(positions) ot.adjust_weights() weights = ot.get_weights() min_w = np.min(weights) max_w = np.max(weights) # display if i % 10 == 0: ot.display_asy(directory + "/we_{:03}.asy".format(int(i / 10)), values=(weights - min_w) / (max_w - min_w), linewidth=0.002) ot.display_asy(directory + "/pd_{:03}.asy".format(int(i / 10)), values=(weights - min_w) / (max_w - min_w), linewidth=0.002, min_rf=0, max_rf=0.35) ot.display_vtk(directory + "/pd_{:03}.vtk".format(i)) # update positions d = 0.75 positions = d * ot.get_centroids() + (1 - d) * positions
max_rho = -1 h_positions = [] for i in range(niter): #print("iteration %d/%d" % (i,niter)) # optimal weights ot.set_positions(positions) ot.adjust_weights() weights = ot.get_weights() # display if i in display_timesteps: print(i) j = display_timesteps.tolist().index(i) diffpos = ot.get_centroids() - positions rho = np.exp(-(diffpos[:, 0]**2 + diffpos[:, 1]**2 - weights) / eps) #if max_rho<0: max_rho = max(rho) ot.display_asy(directory + "/pd_{:03}.asy".format(int(j)), values=rho / max_rho, linewidth=0.00002) #ot.display_vtk( directory + "/pd_{:03}.vtk".format( i ) ) if i in save_timesteps: h_positions.append(positions.copy()) # update positions positions = positions + (tau / eps) * (ot.get_centroids() - positions) np.save(directory + "/positions.npy", h_positions)
class FluidSystem: def __init__( self, domain, positions, velocities, masses, base_filename ): self.ot = OptimalTransport(domain, RadialFuncInBall()) self.ot.set_positions(np.array(positions)) self.ot.set_weights(np.array(masses)/np.pi) self.ot.set_masses(np.array(masses)) self.base_filename = base_filename self.cpt_display = 0 self.max_iter = 200 self.time = 0 # initial centroid positions and velocities self.ot.adjust_weights() self.centroids = self.ot.get_centroids() self.velocities = np.array(velocities) self.coeff_centroid_force = 1e-4 def display( self ): fn = "{}{}.vtk".format( self.base_filename, self.cpt_display ) self.ot.display_vtk( fn, points=True, centroids=True ) self.cpt_display += 1 def make_step( self ): ratio_dt = 1.0 while self.try_step( ratio_dt ) == False: ratio_dt *= 0.5 print( " dt ratio:", ratio_dt ) def try_step( self, ratio_dt ): old_p = self.ot.get_positions() # find dt radii_ap = ( np.array( self.ot.get_masses() ) / np.pi ) ** 0.5 vn2 = np.linalg.norm( self.velocities, axis=1, ord=2 ) dt = ratio_dt * 0.2 / np.max( np.abs( vn2 / radii_ap ) ) adv = dt * self.velocities # target centroid positions + initial guess for the dirac positions target_centroids = self.centroids + adv self.ot.set_positions( old_p + adv ) # stuff to extract centroids, masses, ... d = self.ot.dim() n = self.ot.nb_diracs() rd = np.arange( d * n, dtype=np.int ) b0 = ( d + 1 ) * np.floor_divide( rd, d ) l0 = b0 + rd % d # l1 = (d + 1) * np.arange(n, dtype=np.int) + d # find positions to fit the target centroid positions ratio = 1.0 for num_iter in range( self.max_iter + 1 ): if num_iter == self.max_iter: self.ot.set_positions( old_p ) return False # search dir mvs = self.ot.pd.der_centroids_and_integrals_wrt_weight_and_positions() if mvs.error: self.ot.set_positions( old_p ) ratio *= 0.5 if ratio < 1e-2: return False print( " solve X ratio:", ratio ) continue M = csr_matrix( ( mvs.m_values, mvs.m_columns, mvs.m_offsets ) )[ l0, : ][ :, l0 ] V = mvs.v_values[ l0 ] - target_centroids.flatten() c = self.coeff_centroid_force * np.max( M ) V += c * ( self.ot.get_positions() - target_centroids ).flatten() M += c * diag( 2 * n ) X = spsolve( M, V ).reshape( ( -1, d ) ) # if np.linalg.norm( X, ord=np.inf ) > self.max_disp_at_each_sub_iter: # X *= self.max_disp_at_each_sub_iter / np.linalg.norm( X, ord=np.inf ) self.ot.set_positions( self.ot.get_positions() - ratio * X ) e = np.linalg.norm( X ) # print( " e", e ) if e < 1e-6: break # projection # self.ot.verbosity = 1 self.ot.adjust_weights( relax=0.75 ) # update centroid pos and speed self.time += dt old_centroids = self.centroids self.centroids = self.ot.get_centroids() self.velocities = ( self.centroids - old_centroids ) / dt return True
def run(n, base_filename, l=0.5): # domain domain = ConvexPolyhedraAssembly() domain.add_box([0, 0], [1, 1]) # initial positions, weights and masses positions = [] radius = l / (2 * (n - 1)) mass = l**2 / n**2 for y in np.linspace(radius, l - radius, n): for x in np.linspace(0.5 - l / 2 + radius, 0.5 + l / 2 - radius, n): nx = x + 0.0 * radius * (np.random.rand() - 0.5) ny = y + 0.0 * radius * (np.random.rand() - 0.5) positions.append([nx, ny]) positions = np.array(positions) nb_diracs = positions.shape[0] dim = positions.shape[1] # OptimalTransport ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_masses(np.ones(nb_diracs) * mass) ot.set_positions(positions) ot.max_iter = 100 ot.adjust_weights() ot.display_vtk(base_filename + "0.vtk", points=True, centroids=True) # gravity G = np.zeros((nb_diracs, dim)) G[:, 1] = -9.81 # eps = 0.5 dt = radius * 0.1 V = np.zeros((nb_diracs, dim)) M = np.stack([ot.get_masses() for d in range(dim)]).transpose() for num_iter in range(500): print("num_iter:", num_iter, "dt:", dt) C = ot.get_centroids() X = ot.get_positions() A = G + (C - ot.get_positions()) / (M * eps**2) while True: dV = dt * A dX = dt * (V + dV) if np.max(np.linalg.norm(dX, axis=1, ord=2)) < 0.2 * radius: dt *= 1.05 V += dV X += dX break dt *= 0.5 ot.set_positions(X) ot.adjust_weights() # display n1 = int(num_iter / 1) + 1 ot.display_vtk(base_filename + "{}.vtk".format(n1), points=True, centroids=True)