Пример #1
0
//
// Solves a linear system iteratively via conjugate-gradient
//
// A: complex matrix
// y:  right-hand side
// x0:  initial guess
// nmax:  max number of iterations
// tol:  tolerance
// [[Rcpp::export]]
arma::cx_mat cpp_cg_solve(const arma::cx_mat& A,
			 const arma::cx_mat& y,
			 arma::cx_mat& x0,
			 const double nmax,
			 const double tol)
{

  int n = 0, ii = 0; // counter
  const int nr = y.n_cols; // number of right-hand side cols
  double rel_error = 1e4; // large value
  const int N = y.n_rows;

  // temporary variables
  double alpha_i, beta_i;
  const arma::cx_mat B = A.t(); // Hermitian transpose.
                                // Note: diag blocks not symmetric, so no easier way
  arma::cx_colvec y_i(N), z_i(N), g_i(N), p_i(N), w_i(N), v_i(N), x_i(N);
  arma::cx_colvec g_ip1(N), p_ip1(N), w_ip1(N), v_ip1(N), x_ip1(N);

  // loop over RHS cols
  for (ii=0; ii < nr; ii++){

    // initial step
    y_i = y.col(ii);
    z_i = B * y_i;
    x_i = x0.col(ii);
    g_i = z_i - B * A * x_i;
    p_i = g_i;
    w_i = A * x_i;
    v_i = A * p_i;

    n = 0; rel_error = 1e4;
    while ((n < nmax) && (rel_error > tol)){

      alpha_i = real(cdot(g_i, g_i) / cdot(v_i, v_i));
      x_ip1 = x_i + alpha_i * p_i;
      w_ip1 = w_i + alpha_i * v_i;
      g_ip1 = z_i - B * w_ip1;
      beta_i = real(cdot(g_ip1,g_ip1) / cdot(g_i,g_i));
      // updating
      p_i = g_ip1 + beta_i * p_i;
      v_i = A * p_i;
      rel_error = norm(x_ip1 - x_i) / norm(x_ip1) ;
      x_i = x_ip1;
      if(rel_error < tol) break; // skip cost of next line
      w_i = A * x_i;
      g_i = g_ip1;
      n++;
    }; // end while
    x0.col(ii) = x_i;
  }; //end loop

  return x0;
}
Пример #2
0
    //
    // Angle-resolved spectra for linear or circular polarisations
    //
    // kn: vector of incident wavenumbers
    // medium: surrounding refractive index
    // R: Nx3 matrix of positions
    // Alpha: 3NxNl matrix of principal polarisabilities
    // Angles:  Nx3 matrix of particle rotation angles
    // Incidence:  Ni vector of incident beam directions
    // Axes:  Ni vector of incident beam axes
    // ScatteringNodes:  2xNs matrix of scattered field directions
    // ScatteringWeights:  Ns vector of scattered field quadrature weights
    // polarisation: integer flag to switch between linear and circular polarisation
    // inversion: integer flag to use different inversion methods
    // maxiter:  max number of iterations
    // tol:  tolerance
    // progress: logical flag to display progress bars
    // [[Rcpp::export]]
    arma::cube cpp_dispersion_spectrum(const arma::colvec kn,
      const double medium,
      const arma::mat& R,
      const arma::cx_mat& Alpha,
      const arma::mat& Angles,
      const arma::vec& Incidence,
      const arma::ivec& Axes,
      const arma::mat& ScatteringNodes,
      const arma::vec& ScatteringWeights,
      const int polarisation,
      const int inversion,
      const int maxiter,
      const double tol,
      const bool progress)
      {

        const int Ni = Incidence.n_elem;
        int Nl = kn.n_elem, Nr = R.n_cols, ll;
        arma::cube res(Ni, 6, Nl);
        arma::mat tmp(Ni, 6);

        // global, will update at each wavelength
        arma::cx_cube AlphaBlocks = arma::zeros<arma::cx_cube>(3, 3, Nr);

        // global, will update at each wavelength
        arma::cx_mat A(3*Nr, 3*Nr );
        if(inversion < 2) { // full interaction matrix
          A.eye();
        } else if (inversion == 2){ // only propagator G = I - A
          A.zeros();
        }

        for(ll=0; ll<Nl; ll++){ // loop over kn
          if(progress)
          progress_bar(ll+1,Nl);

          // update in place
          cpp_alpha_blocks_update(Alpha.col(ll), Angles, AlphaBlocks);

          // if solve or cg, need full A, otherwise just G
          if(inversion < 2) { // full interaction matrix
            // update in place
            cpp_interaction_matrix_update(R, kn(ll), AlphaBlocks, A);
          } else if (inversion == 2){ // only propagator G = I - A
            // update in place
            cpp_propagator_update(R, kn(ll), AlphaBlocks, A);
          }

          tmp = cpp_dispersion(R, A, AlphaBlocks, kn(ll), medium,
          Incidence, Axes, ScatteringNodes, ScatteringWeights, polarisation, inversion, maxiter, tol);
          // Rcpp::Rcout << tmp << "\n";

          res.slice(ll) = 1.0/Nr * tmp;
        }
        if(progress)
        Rcpp::Rcout << "\n";

        return res ;
      }
Пример #3
0
Файл: cI.cpp Проект: sjjko/ksdft
arma::cx_mat cI::operator*(arma::cx_mat  input)
{


arma::cx_mat outputMAT(prod(_S),input.n_cols);


if(input.n_rows==prod(_S))
{
    for(unsigned int i=0;i<input.n_cols;i++)
    {
        //func_fftn(arma::cx_vec vec_Inp,arma::Col<int> S,const string forward_or_backward)
        //check(_Faktor,input.col(i),"*"); // check if _Faktor has as many cols as input rows
        outputMAT.col(i)=func_fftn(input.col(i),this->_S,"backward");
    }
}
else
{
   // verbosity(*_Pa,"CI: do the transform",2,__FILE__,__LINE__);

    for(unsigned int i=0;i<input.n_cols;i++)
    {
    //verbosity(*_Pa,"CI: do it for column"+std::to_string(i),2,__FILE__,__LINE__);

        //func_fftn(arma::cx_vec vec_Inp,arma::Col<int> S,const string forward_or_backward)
        //check(_Faktor,input.col(i),"*"); // check if _Faktor has as many cols as input rows
//        cout << size(full(_Pa->activeIndices)) << endl;
//                cout << size(input) << endl;
//                cout << size(input.col(i)) << endl;
//                cout << size(test) << endl;

//        for(int j=0;j<_Pa->numberOfActiveIndices;j++)
//        {
//        cout << uv(j) << " " << j << endl;
//        full(uv(j),0)=input(j,i);
//        }
        _full=arma::zeros<arma::cx_mat>(arma::prod(_S),1);
        _full(_uv)=input.col(i);
        outputMAT.col(i)=func_fftn(_full,this->_S,"backward");
    }
}

return outputMAT;
}