def proj_noncongested(points, domain, center=None, mass=None, radial_func=RadialFuncInBall(), verbose=None): nb_points = len(points) assert (nb_points != 0) if mass is None: mass = np.ones(nb_points) / nb_points laguerre = OptimalTransport(positions=points, weights=None, masses=mass, domain=domain, radial_func=radial_func, linear_solver="CuPyx") if not center is None: initialize_weights(power_diagram=laguerre.pd, center=center, verbose=verbose) laguerre.adjust_weights(relax=1) if np.linalg.norm(laguerre.pd.integrals() - mass) > 1e-5: print("The Newton algorithm did not converge!") laguerre.display_vtk("debug_file/bad_Newton.vtk", points=True) laguerre.get_domain().display_boundaries_vtk( "debug_file/bad_Newton_domain.vtk") np.save("debug_file/bad_positions", laguerre.get_positions()) np.save("debug_file/integrals", laguerre.pd.integrals()) np.save("debug_file/bad_weights", laguerre.get_weights()) assert (False) return laguerre.pd
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 run(n, base_filename): domain = ConvexPolyhedraAssembly() domain.add_box([0, 0], [1, 1]) domain.add_box([0.2, -0.5], [0.8, 0]) positions = [] radius = 0.5 / (2 * (n - 1)) for y in np.linspace(radius, 0.5 + radius, n): for x in np.linspace(radius, 0.5 + radius, n): positions.append([x, y]) nb_diracs = len(positions) # ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_masses(np.ones(nb_diracs) * 0.8 * 0.5**2 / nb_diracs) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_positions(np.array(positions)) b_old = ot.pd.centroids() ot.adjust_weights() ot.display_vtk(base_filename + "0.vtk") nb_timesteps = int(20 / radius) v = np.zeros((nb_diracs, 2)) dt = 0.003 * radius for i in range(nb_timesteps): print(i, "/", nb_timesteps) # first trial v[:, 1] -= 1 p_old = ot.get_positions() p_tst = p_old + dt * v ot.set_positions(p_tst) ot.adjust_weights() # display d = int(n / 5) if i % d == 0: ot.display_vtk(base_filename + "{:03}.vtk".format(1 + int(i / d))) # corrections b_new = ot.pd.centroids() v = (b_new - b_old) / dt ot.set_positions(b_new) b_old = b_new
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 )
from pysdot.domain_types import ConvexPolyhedraAssembly from pysdot import OptimalTransport import numpy as np positions = np.random.rand(200, 2) # diracs ot = OptimalTransport() ot.set_positions(np.array(positions)) ot.set_weights(np.ones(ot.get_positions().shape[0])) ot.verbosity = 1 # solve ot.adjust_weights() # display ot.display_vtk("results/pd.vtk") # print( ot.pd.display_html() )
from pysdot.domain_types import ConvexPolyhedraAssembly from pysdot.radial_funcs import RadialFuncInBall from pysdot import OptimalTransport import numpy as np domain = ConvexPolyhedraAssembly() domain.add_box([0, 0], [1, 10]) R = 0.5 ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_masses(np.array([np.pi * R**2 / 2])) ot.set_weights(np.array([R**2])) cpt = 0 for y in np.linspace(0, -20, 100): ot.set_positions(np.array([[0.5, y]])) ot.adjust_weights() r = ot.get_weights()[0]**0.5 a = np.arcsin(R / r) e = 0.5 * r * (np.pi / 2 * np.sin(a) - a / np.sin(a) + np.cos(a)) f = 0.5 * (np.cos(a) + a / np.sin(a)) yp = y + r * f print(y, yp) ot.display_vtk("lc_{}.vtk".format(cpt)) cpt += 1
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 ) positions += timestep*(descent_direction + (centroids-positions)/epsilon) for n in range( positions.shape[ 0 ] ): if timeout[ n ] == 0 and positions[ n, 0 ] > 4*alpha/3: timeout[ n ] = i + 1
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))
for dist_name in ["uniform"]: # , "voro_50" for dim in [3]: for nb_diracs in map( int, [1e5 / 8, 1e5 / 4, 1e5 / 2]): # 1e5, 2e5, 4e5, 8e5, 16e5 positions = make_positions(dist_name, nb_diracs, dim) # diracs ot = OptimalTransport(positions=positions) ot.verbosity = 1 # solve print(dim, nb_diracs) ot.adjust_weights() # display, save if nb_diracs <= 1e6: ot.display_vtk("vtk/pd.vtk", points=True) pw = np.zeros([dim + 1, nb_diracs]) for d in range(dim): pw[d, :] = positions[:, d] np.save( "/data/sdot/{}_{}_{}D_equalw.npy".format( dist_name, nb_diracs, dim), pw) pw[dim, :] = ot.get_weights() np.save( "/data/sdot/{}_{}_{}D_solved.npy".format( dist_name, nb_diracs, dim), pw)
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)