 hotel – establish a Oasis connection, and you will receive an IPv6 address.
the fully fledged dual stack VPN from Oasis can improve your connection stability and speed.
Since Oasis Oasis VPN, you are automatically protected from that, no matter where you are.
– Stealth VPN technology for restricted networks
With Oasis VPN app, you can use the new Stealth VPN functionality.
The feature, also known as obfuscated VPN, can mask your VPN packets so that they look like normal web traffic.
With the stealth feature, you can also get around nationwide internet restrictions in some countries with top firewall system.
you can use Oasis VPN just like in any unrestricted network..
– No need to register!!!
Only need one simple step to use Oasis VPN server, and then you can enjoy the most safe and fastest Internet environment.
– Leading encryption technology 🛡
Oasis VPN uses the highest level encryption technology so that all kinds of users’ information are completely hidden,
and it is not affected by throttling, hacker attacks, etc.
– Fast servers all over the world
a lot of stable servers all over the world, easily switch the best quality servers in different regions with one click.
– Smooth dedicated server
Perfectly accelerate mobile games, speed up website access speed, and perfectly support popular video platforms
such as Netflix, HULU, Disney+, HBO, Line, Instagram, Snapchat, Twitter, Facebook, WhatsApp, YouTube, etc.
– Zero log
Never actively record any of your usage records!!! Therefore, you can safely browse any page you want without having to worry about their information being leaked.
Join Oasis VPN now and you can:
– Browse sites on IPv6 network infrastructure.
– Surf the Internet at the Fastest VPN Speed
– Test Internet Speed
– The stable VPN server
– This unlimited VPN does not require you to register, just one step, then you can fully enjoy this VPN to bring you the fun of surfing the web,
access to any content you want.
Feel free to let us know if you have any problems of using Oasis VPN server.
We will help you solve the problem in the shortest time and guarantee your use experience.
You need to know that the team of Oasis VPN is always ready 24/7 to assist you.
Fixed Minor Bug
Added Fast Serversfrom __future__ import print_function
from..Model import Struct
import numpy as np
import inspect

class WriteProp(object):
    def __init__(self, prop):
        self._write(prop)
    def _write(self, prop):
        pass
        #print (prop)

class RandomGrid(object):
    """
    Base class for Random grids
    """
    def __init__(self, pos_c, axis, z_min, z_max, dx):
        self.pos_c = np.asarray(pos_c)
        self.axis = np.asarray(axis)
        self.pos_f = self.pos_c + self.axis
        self.z_min = z_min
        self.z_max = z_max
        self.dx = dx        
        
    def _axis(self):
        r_seg = self.axis
        r_seg_mag = np.linalg.norm(r_seg) #Outflow axis magnitude (preliminary)

        self.r_seg_dir = r_seg/r_seg_mag #Axis direction
        if self.z_max is not None: self.r_seg = (self.z_max - self.z_min) * self.r_seg_dir #If set z_max, then the segment length is zmax-zmin  
        else: self.r_seg = r_seg - self.z_min * self.r_seg_dir #New axis, only taking into account z_min
        self.r_seg_mag = np.linalg.norm(self.r_seg) #Final axis magnitude
        self.dr = self.dx * 2.**-1 #3.**-1#2.5**-1
        return self.r_seg_dir

    def _grid(self, func_width):
        
        #Guess the number of random grid points to generate: (approximation to a rectangular region)
        # Number of divisions along the main segment, 
        #  times the number of divisions along an axis perpendicular to the segment,
        #   times the number of divisions along an axis perpendicular to both of the segments above.
        #    times an exageration factor (in dr) to increase the number of grid points.
        #     Twice to accoutn for the other branch of the jet.

        mean_w = func_width(0.5 * self.r_seg_mag)
        self.NPoints = 2 * int(self.r_seg_mag/self.dr * (mean_w/self.dr)**2 ) 
        print ('Number of grid points:', self.NPoints)
        
        self.grid = np.zeros((self.NPoints, 4)) #x,y,z,r
        half_points = int(self.NPoints/2)
        r_vec = np.zeros((half_points, 3))
        rand_vec_plane = np.zeros((half_points, 3))
                
        r = np.random.uniform(self.z_min, self.z_min+self.r_seg_mag, size = half_points) 
        width = func_width(r)
        for i in range(half_points):
            r_vec[i] = r[i] * self.r_seg_dir #Random vector along the long axis
            R = np.random.uniform(0, width[i]) #Random R from the long axis

            rand_vec = np.random.uniform(-1,1,3) #Random vector to generate the perpendicular vector to the outflow axis
            rand_vec = rand_vec / np.linalg.norm(rand_vec)
            cross_unit = np.cross(self.r_seg_dir, rand_vec)
            cross_unit = cross_unit / np.linalg.norm(cross_unit) #Perpendicular (random) unitary vector to the outflow axis
            rand_vec_plane[i] = R * cross_unit #Perpendicular (random) vector to the outflow axis

        r_c = r_vec + rand_vec_plane #Vector from the outflow center to the generated point
        r_real = self.pos_c + r_c #Real position from the origin of coordinates
        r_real_n = self.pos_c - r_c #Mirror point to real position from the origin of coordinates

        r = np.expand_dims(r, axis=0) # or r[np.newaxis]
        self.grid[0:half_points] = np.append(r_real, r.T, axis=1)
        self.grid[half_points:] = np.append(r_real_n, r.T, axis=1)
        r_c_dir = r_c / np.linalg.norm(r_c, axis = 1)[np.newaxis].T
        self.r_c_dir = np.append(r_c_dir, -1*r_c_dir, axis = 0) 
        """
        self.r_c_dir = np.append(np.repeat([self.r_seg_dir], half_points, axis=0),
                                 np.repeat([-1*self.r_seg_dir], half_points, axis=0),
                                 axis = 0)
        """
        self.width = np.append(width, width)
                
class OutflowModel(RandomGrid):
   
    def __init__(self, pos_c, axis, z_min, z_max, dx):
        """
        Host class for outflow models. The grid points are generated randomly taking into account the Jet model geometry.

        Available models:

           -'reynolds86': Jet Model (`Reynolds+1986`_)

        Input units: SI (metres, kilograms, seconds).

        Parameters
        ----------
        pos_c : array_like, shape (3,) 
           Origin of coordinates on the axis.

        axis : array_like, shape (3,) 
           Long axis direction, of arbitrary length. For example, an axis pointing to the z-direction: axis = [0,0,1]  

        z_min : scalar
           Axis lower limit to compute the physical properties.

        z_max : scalar
           Axis upper limit to compute the physical properties. The axis extent will be [z_min, z_max].

        dx : scalar
           Maximum separation between two adjacent grid points. This will prevent void holes when merging this random grid into a regular grid of nodes separation = dx.       

        mirror : bool, optional
           If True, it is assumed that the model is symmetric to the reference position ``pos_c``. Defaults to True