예제 #1
0
def test_1V():

    obj = test()

    obj.single_mode_evolution = False

    f_generalized = MB_dist(obj.q1_center, obj.q2_center, obj.p1, obj.p2,
                            obj.p3, 1)

    C_f_hat_generalized = 2 * af.fft2(
        collision_operator.BGK(
            f_generalized, obj.q1_center, obj.q2_center, obj.p1, obj.p2,
            obj.p3, obj.compute_moments,
            obj.physical_system.params)) / (obj.N_q2 * obj.N_q1)

    # Background
    C_f_hat_generalized[0, 0, :] = 0

    # Finding the indices of the mode excited:
    i_q1_max = np.unravel_index(
        af.imax(af.abs(C_f_hat_generalized))[1],
        (obj.N_q1, obj.N_q2, obj.N_p1 * obj.N_p2 * obj.N_p3),
        order='F')[0]

    i_q2_max = np.unravel_index(
        af.imax(af.abs(C_f_hat_generalized))[1],
        (obj.N_q1, obj.N_q2, obj.N_p1 * obj.N_p2 * obj.N_p3),
        order='F')[1]

    obj.p1 = np.array(af.reorder(obj.p1, 1, 2, 3, 0))
    obj.p2 = np.array(af.reorder(obj.p2, 1, 2, 3, 0))
    obj.p3 = np.array(af.reorder(obj.p3, 1, 2, 3, 0))

    delta_f_hat = 0.01 * (1 / (2 * np.pi))**(1 / 2) \
                       * np.exp(-0.5 * obj.p1**2)

    obj.single_mode_evolution = True

    C_f_hat_single_mode = collision_operator.linearized_BGK(
        delta_f_hat, obj.p1, obj.p2, obj.p3, obj.compute_moments,
        obj.physical_system.params)

    assert (af.mean(
        af.abs(
            af.flat(C_f_hat_generalized[i_q1_max, i_q2_max]) -
            af.to_array(C_f_hat_single_mode.flatten()))) < 1e-14)
예제 #2
0
파일: _array.py 프로젝트: eeeedgar/model_1
def argmax(a: ndarray,
           axis: tp.Optional[int] = None,
           out: tp.Optional[ndarray] = None) -> ndarray:
    if out:
        raise ValueError('out != None is not supported')

    val, idx = af.imax(a._af_array, dim=axis)
    return _wrap_af_array(idx)
예제 #3
0
파일: _array.py 프로젝트: eeeedgar/model_1
    def argmax(self,
               axis: tp.Optional[int] = None,
               out: tp.Optional['ndarray'] = None):
        """
        Return indices of the maximum values along the given axis.
        """

        val, idx = af.imax(self._af_array, dim=axis)
        return _wrap_af_array(idx)
예제 #4
0
 def predict_proba1(self, X):
     near_locs, near_dists = af.vision.nearest_neighbour(X, self._data, self._dim, \
                                                         self._num_nearest, self._match_type)
     weights = self._get_neighbor_weights(near_dists)
     top_labels = af.moddims(self._labels[near_locs], \
                             get_dims(near_locs)[0], get_dims(near_locs)[1])
     accum_weights = af.scan_by_key(
         top_labels, weights)  # reduce by key would be more ideal
     probs, _ = af.imax(accum_weights, dim=0)
     return probs.T
예제 #5
0
 def _predict_proba(self, query, train_feats, train_labels, k, dist_type,
                    weight_by_dist):
     near_locs, near_dists = af.vision.nearest_neighbour(query, train_feats, 1, \
                                                         k, dist_type)
     weights = self._get_neighbor_weights(near_dists, weight_by_dist, k)
     top_labels = af.moddims(train_labels[near_locs], \
                             near_locs.dims()[0], near_locs.dims()[1])
     accum_weights = af.scan_by_key(
         top_labels, weights)  # reduce by key would be more ideal
     probs, _ = af.imax(accum_weights, dim=0)
     return probs.T
예제 #6
0
 def argmax(self, axis=None):
     if axis is None:
         return self.flat.argmax(axis=0)
     if not isinstance(axis, numbers.Number):
         raise TypeError('an integer is required for the axis')
     val, idx = arrayfire.imax(self.d_array, pu.c2f(self.shape, axis))
     shape = list(self.shape)
     shape.pop(axis)
     if(len(shape)):
         return ndarray(shape, dtype=pu.typemap(idx.dtype()), af_array=idx)
     else:
         return ndarray(shape, dtype=pu.typemap(idx.dtype()), af_array=idx)[()]
예제 #7
0
 def argmax(self, axis=None):
     if axis is None:
         return self.flat.argmax(axis=0)
     if not isinstance(axis, numbers.Number):
         raise TypeError('an integer is required for the axis')
     val, idx = arrayfire.imax(self.d_array, pu.c2f(self.shape, axis))
     shape = list(self.shape)
     shape.pop(axis)
     if (len(shape)):
         return ndarray(shape, dtype=pu.typemap(idx.dtype()), af_array=idx)
     else:
         return ndarray(shape, dtype=pu.typemap(idx.dtype()),
                        af_array=idx)[()]
예제 #8
0
 def predict(self, X):
     near_locs, near_dists = af.vision.nearest_neighbour(X, self._data, self._dim, \
                                                         self._num_nearest, self._match_type)
     weights = self._get_neighbor_weights(near_dists)
     top_labels = af.moddims(self._labels[near_locs], \
                             get_dims(near_locs)[0], get_dims(near_locs)[1])
     accum_weights = af.scan_by_key(
         top_labels, weights)  # reduce by key would be more ideal
     _, max_weight_locs = af.imax(accum_weights, dim=0)
     pred_idxs = af.range(get_dims(accum_weights)[1]) * get_dims(
         accum_weights)[0] + max_weight_locs.T
     top_labels_flat = af.flat(top_labels)
     pred_classes = top_labels_flat[pred_idxs]
     return pred_classes
예제 #9
0
 def _predict(self, query, train_feats, train_labels, k, dist_type,
              weight_by_dist):
     near_locs, near_dists = af.vision.nearest_neighbour(query, train_feats, 1, \
                                                         k, dist_type)
     weights = self._get_neighbor_weights(near_dists, weight_by_dist, k)
     top_labels = af.moddims(train_labels[near_locs], \
                             near_locs.dims()[0], near_locs.dims()[1])
     accum_weights = af.scan_by_key(
         top_labels, weights)  # reduce by key would be more ideal
     _, max_weight_locs = af.imax(accum_weights, dim=0)
     pred_idxs = af.range(accum_weights.dims()
                          [1]) * accum_weights.dims()[0] + max_weight_locs.T
     top_labels_flat = af.flat(top_labels)
     pred_classes = top_labels_flat[pred_idxs]
     return pred_classes
예제 #10
0
 def predict(self, X):
     probs = self.predict_proba(X)
     _, classes = af.imax(probs, 1)
     return classes
예제 #11
0
def accuracy(predicted, target):
    _, tlabels = af.imax(target, 1)
    _, plabels = af.imax(predicted, 1)
    return 100 * af.count(plabels == tlabels) / tlabels.elements()
def predict_class(X, Weights):
    probs = predict_prob(X, Weights)
    _, classes = af.imax(probs, 1)
    return classes
 def _predict(self, X: af.Array, Weights: af.Array) -> af.Array:
     probs = self._predict_proba(X, Weights)
     _, classes = af.imax(probs, 1)
     classes = classes + self._label_offset
     return classes
예제 #14
0
    def _initialize(self, params):
        """
        Called when the solver object is declared. This function is
        used to initialize the distribution function, and the field
        quantities using the options as provided by the user. The
        quantities are then mapped to the fourier basis by taking FFTs.
        The independant modes are then evolved by using the linear
        solver.
        """
        # af.broadcast(function, *args) performs batched operations on
        # function(*args):
        f     = af.broadcast(self.physical_system.initial_conditions.\
                             initialize_f, self.q1_center, self.q2_center,
                             self.p1, self.p2, self.p3, params
                             )
        # Taking FFT:
        f_hat = af.fft2(f)

        # Since (k_q1, k_q2) = (0, 0) will give the background distribution:
        # The division by (self.N_q1 * self.N_q2) is performed since the FFT
        # at (0, 0) returns (amplitude * (self.N_q1 * self.N_q2))
        self.f_background = af.abs(f_hat[0, 0, :])/ (self.N_q1 * self.N_q2)

        # Calculating derivatives of the background distribution function:
        self._calculate_dfdp_background()
   
        # Scaling Appropriately:
        # Except the case of (0, 0) the FFT returns
        # (0.5 * amplitude * (self.N_q1 * self.N_q2)):
        f_hat = 2 * f_hat / (self.N_q1 * self.N_q2)

        if(self.single_mode_evolution == True):
            # Background
            f_hat[0, 0, :] = 0

            # Finding the indices of the perturbation introduced:
            i_q1_max = np.unravel_index(af.imax(af.abs(f_hat))[1], 
                                        (self.N_q1, self.N_q2, 
                                         self.N_p1 * self.N_p2 * self.N_p3
                                        ),order = 'F'
                                       )[0]

            i_q2_max = np.unravel_index(af.imax(af.abs(f_hat))[1], 
                                        (self.N_q1, self.N_q2, 
                                         self.N_p1 * self.N_p2 * self.N_p3
                                        ),order = 'F'
                                       )[1]

            # Taking sum to get a scalar value:
            params.k_q1 = af.sum(self.k_q1[i_q1_max, i_q2_max])
            params.k_q2 = af.sum(self.k_q2[i_q1_max, i_q2_max])

            self.f_background = np.array(self.f_background).\
                                reshape(self.N_p1, self.N_p2, self.N_p3)

            self.p1 = np.array(self.p1).\
                      reshape(self.N_p1, self.N_p2, self.N_p3)
            self.p2 = np.array(self.p2).\
                      reshape(self.N_p1, self.N_p2, self.N_p3)
            self.p3 = np.array(self.p3).\
                      reshape(self.N_p1, self.N_p2, self.N_p3)

            self._A_q1 = np.array(self._A_q1).\
                         reshape(self.N_p1, self.N_p2, self.N_p3)
            self._A_q2 = np.array(self._A_q2).\
                         reshape(self.N_p1, self.N_p2, self.N_p3)

            params.rho_background = self.compute_moments('density',
                                                         self.f_background
                                                        )
            
            params.p1_bulk_background = self.compute_moments('mom_p1_bulk',
                                                             self.f_background
                                                            ) / params.rho_background
            params.p2_bulk_background = self.compute_moments('mom_p2_bulk',
                                                             self.f_background
                                                            ) / params.rho_background
            params.p3_bulk_background = self.compute_moments('mom_p3_bulk',
                                                             self.f_background
                                                            ) / params.rho_background
            
            params.T_background = ((1 / params.p_dim) * \
                                   self.compute_moments('energy',
                                                        self.f_background
                                                       )
                                   - params.rho_background * 
                                     params.p1_bulk_background**2
                                   - params.rho_background * 
                                     params.p2_bulk_background**2
                                   - params.rho_background * 
                                     params.p3_bulk_background**2
                                  ) / params.rho_background

            self.dfdp1_background = np.array(self.dfdp1_background).\
                                    reshape(self.N_p1, self.N_p2, self.N_p3)
            self.dfdp2_background = np.array(self.dfdp2_background).\
                                    reshape(self.N_p1, self.N_p2, self.N_p3)
            self.dfdp3_background = np.array(self.dfdp3_background).\
                                    reshape(self.N_p1, self.N_p2, self.N_p3)

            # Unable to recover pert_real and pert_imag accurately from the input.
            # There seems to be some error in recovering these quantities which
            # is dependant upon the resolution. Using user-defined quantities instead
            delta_f_hat =   params.pert_real * self.f_background \
                          + params.pert_imag * self.f_background * 1j 

            self.Y = np.array([delta_f_hat])
            compute_electrostatic_fields(self)
            self.Y = np.array([delta_f_hat, 
                               self.delta_E1_hat, self.delta_E2_hat, self.delta_E3_hat,
                               self.delta_B1_hat, self.delta_B2_hat, self.delta_B3_hat
                              ]
                             )

        else:
            # Using a vector Y to evolve the system:
            self.Y = af.constant(0, self.N_q1, self.N_q2,
                                 self.N_p1 * self.N_p2 * self.N_p3,
                                 7, dtype = af.Dtype.c64
                                )

            # Assigning the 0th indice along axis 3 to the f_hat:
            self.Y[:, :, :, 0] = f_hat

            # Initializing the EM field quantities:
            self.E3_hat = af.constant(0, self.N_q1, self.N_q2,
                                      self.N_p1 * self.N_p2 * self.N_p3, 
                                      dtype = af.Dtype.c64
                                     )

            self.B1_hat = af.constant(0, self.N_q1, self.N_q2,
                                      self.N_p1 * self.N_p2 * self.N_p3,
                                      dtype = af.Dtype.c64
                                     )
            
            self.B2_hat = af.constant(0, self.N_q1, self.N_q2,
                                      self.N_p1 * self.N_p2 * self.N_p3,
                                      dtype = af.Dtype.c64
                                     ) 
            
            self.B3_hat = af.constant(0, self.N_q1, self.N_q2,
                                      self.N_p1 * self.N_p2 * self.N_p3,
                                      dtype = af.Dtype.c64
                                     )
            
            # Initializing EM fields using Poisson Equation:
            if(self.physical_system.params.fields_initialize == 'electrostatic' or
               self.physical_system.params.fields_initialize == 'fft'
              ):
                compute_electrostatic_fields(self)

            # If option is given as user-defined:
            elif(self.physical_system.params.fields_initialize == 'user-defined'):
                E1, E2, E3 = \
                    self.physical_system.initial_conditions.initialize_E(self.q1_center, self.q2_center, self.physical_system.params)
                
                B1, B2, B3 = \
                    self.physical_system.initial_conditions.initialize_B(self.q1_center, self.q2_center, self.physical_system.params)

                # Scaling Appropriately
                self.E1_hat = af.tile(2 * af.fft2(E1) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                self.E2_hat = af.tile(2 * af.fft2(E2) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                self.E3_hat = af.tile(2 * af.fft2(E3) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                self.B1_hat = af.tile(2 * af.fft2(B1) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                self.B2_hat = af.tile(2 * af.fft2(B2) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                self.B3_hat = af.tile(2 * af.fft2(B3) / (self.N_q1 * self.N_q2), 1, 1, self.N_p1 * self.N_p2 * self.N_p3)
                
            else:
                raise NotImplementedError('Method invalid/not-implemented')

            # Assigning other indices along axis 3 to be
            # the EM field quantities:
            self.Y[:, :, :, 1] = self.E1_hat
            self.Y[:, :, :, 2] = self.E2_hat
            self.Y[:, :, :, 3] = self.E3_hat
            self.Y[:, :, :, 4] = self.B1_hat
            self.Y[:, :, :, 5] = self.B2_hat
            self.Y[:, :, :, 6] = self.B3_hat

            af.eval(self.Y)

        return
예제 #15
0
파일: aflib.py 프로젝트: bfrosik/pycdi
 def argmax(arr, axis=None):
     val, idx = af.imax(arr, axis)
     return idx