def optimal_transport(density, Y, masses, psi0 = None, err=1e-8): center = (density.min_position() + density.max_position())/2 halfsides = (density.max_position() - density.min_position())/2 ratio = 1/np.max(np.abs((Y-center)/halfsides)) psi = (1-ratio)*np.sum((Y-center)**2, axis=-1) ot = OptimalTransport(Y, psi, density, radial_func=RadialFuncUnit(), obj_max_dw=err) ot.set_masses(masses) ot.adjust_weights() return ot.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
def test_ball_cut(self, nb_diracs=100): for _ in range(10): ot = OptimalTransport(self.domain, RadialFuncInBall()) positions = np.random.rand(nb_diracs, 2) positions[:, 1] *= 0.5 radius = 0.25 / nb_diracs**0.5 mass = np.pi * radius**2 # diracs ot.set_positions(positions) ot.set_weights(np.ones(nb_diracs) * radius**2) ot.set_masses(np.ones(nb_diracs) * mass) # optimal weights ot.adjust_weights() # integrals areas = ot.pd.integrals() self.assertAlmostEqual(np.min(areas), mass, places=6) self.assertAlmostEqual(np.max(areas), mass, places=6)
if obstacle_radius: domain.add_convex_polyhedron( np.array( pon ), -1.0 ) domain.display_boundaries_vtk( directory + "/bound.vtk" ) # domain_asy = "draw((0,0)--(3,0)--(3,1)--(4,1)--(4,0)--(7,0)--(7,3)--(4,3)--(4,2)--(3,2)--(3,3)--(0,3)--cycle);\n" s = 0.5 * target_radius g = GradGrid( domain, [ [ limx - 2 * s, 0.5 ] ], s ) # iterations color_values = positions[ :, 1 ] color_values = ( color_values - np.min( color_values ) ) / np.ptp( color_values ) 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
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
domain = ConvexPolyhedraAssembly() domain.add_convex_polyhedron([ [0, 0, +1, -1], [9, 9, 0, +1], [-9, 9, -1, -1], ]) domain.display_boundaries_vtk(directory + "/bounds.vtk") color_values = 0.5 * np.linalg.norm( positions, axis=1, keepdims=True, ord=2) color_values = (color_values - np.min(color_values)) / ( np.max(color_values) - np.min(color_values)) ot = OptimalTransport(domain, RadialFuncInBall()) ot.set_weights(weights) ot.set_masses(np.ones(positions.shape[0]) * mass) nb_timesteps = int(3 / target_radius) for i in range(nb_timesteps): # change positions positions -= 0.4 * target_radius / np.linalg.norm( positions, axis=1, keepdims=True, ord=2) * positions ot.set_positions(positions) # optimal weights ot.adjust_weights() # display d = int(n / 5) if i % d == 0: # ot.display_asy( directory + "/pd_{:03}.asy".format( int( i / d ) ), "in_ball(weight**0.5)", positions, weights, domain, values = color_values, linewidth=0.002 )
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))
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)