VALUE rb_gsl_linalg_complex_LU_decomp2(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mnew = NULL; gsl_permutation *p = NULL; int signum, itmp; size_t size; VALUE objm, obj2; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); itmp = 1; break; default: CHECK_MATRIX_COMPLEX(obj); Data_Get_Struct(obj, gsl_matrix_complex, m); itmp = 0; } size = m->size1; mnew = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mnew, m); objm = Data_Wrap_Struct(cgsl_matrix_complex_LU, 0, gsl_matrix_complex_free, mnew); switch (argc-itmp) { case 0: p = gsl_permutation_alloc(size); gsl_linalg_complex_LU_decomp(mnew, p, &signum); obj2 = Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p); return rb_ary_new3(3, objm ,obj2, INT2FIX(signum)); break; case 1: /* when a permutation object is given */ CHECK_PERMUTATION(argv[itmp]); Data_Get_Struct(argv[itmp], gsl_permutation, p); gsl_linalg_complex_LU_decomp(m, p, &signum); return rb_ary_new3(3, objm , argv[itmp], INT2FIX(signum)); break; default: rb_raise(rb_eArgError, "Usage: LU_decomp!() or LU_decomp!(permutation)"); } }
void qpb_sun_project(qpb_link *u, int n) { gsl_eigen_hermv_workspace *gsl_work = gsl_eigen_hermv_alloc(NC); gsl_matrix_complex *B = gsl_matrix_complex_alloc(NC, NC); gsl_matrix_complex *A = gsl_matrix_complex_alloc(NC, NC); gsl_matrix_complex *V = gsl_matrix_complex_alloc(NC, NC); gsl_matrix_complex *U = gsl_matrix_complex_alloc(NC, NC); gsl_matrix_complex *D = gsl_matrix_complex_alloc(NC, NC); gsl_vector *S = gsl_vector_alloc(NC); gsl_permutation *perm = gsl_permutation_alloc(NC); for(int k=0; k<n; k++){ qpb_complex *a = (qpb_complex *)(u + k); for(int i=0; i<NC; i++) for(int j=0; j<NC; j++) gsl_matrix_complex_set(A, i, j, gsl_complex_rect(a[j + i*NC].re, a[j + i*NC].im)); gsl_matrix_complex_memcpy(U, A); int sgn; gsl_linalg_complex_LU_decomp(U, perm, &sgn); gsl_complex det_A = gsl_linalg_complex_LU_det(U, sgn); qpb_double phi = gsl_complex_arg(det_A); gsl_complex one = gsl_complex_rect(1., 0.); gsl_complex zero = gsl_complex_rect(0., 0.); gsl_matrix_complex_memcpy(U, A); svd(U, V, S); get_theta_matrix(D, S, phi); gsl_blas_zgemm(CblasNoTrans, CblasNoTrans, one, U, D, zero, B); gsl_blas_zgemm(CblasNoTrans, CblasConjTrans, one, B, V, zero, A); for(int i=0; i<NC; i++) for(int j=0; j<NC; j++){ a[j + i*NC].re = GSL_REAL(gsl_matrix_complex_get(A, i, j)); a[j + i*NC].im = GSL_IMAG(gsl_matrix_complex_get(A, i, j)); } } gsl_matrix_complex_free(A); gsl_matrix_complex_free(B); gsl_matrix_complex_free(V); gsl_matrix_complex_free(U); gsl_matrix_complex_free(D); gsl_permutation_free(perm); gsl_vector_free(S); gsl_eigen_hermv_free(gsl_work); return; }
static VALUE rb_gsl_linalg_complex_LU_svx(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_vector_complex *x = NULL; int flagm = 0, itmp, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 0; } if (flagm == 1) { if (itmp != argc-1) rb_raise(rb_eArgError, "Usage: m.LU_solve(b)"); Data_Get_Struct(argv[itmp], gsl_vector_complex, x); p = gsl_permutation_alloc(x->size); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); itmp++; Data_Get_Struct(argv[itmp], gsl_vector_complex, x); itmp++; } gsl_linalg_complex_LU_svx(mtmp, p, x); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return argv[argc-1]; }
void DAESolver::decomp_jacobian_matrix() { int a_sign_num; if (the_system_size_ == 0) { return; } gsl_linalg_LU_decomp(the_jacobian_matrix1_, the_permutation1_, &a_sign_num); gsl_linalg_complex_LU_decomp(the_jacobian_matrix2_, the_permutation2_, &a_sign_num); }
static VALUE rb_gsl_linalg_complex_LU_sgndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_complex *z = NULL; VALUE vz; int flagm = 0, signum, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 0; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { if (itmp != argc-1) rb_raise(rb_eArgError, "signum not given"); signum = NUM2DBL(argv[itmp]); } vz = Data_Make_Struct(cgsl_complex, gsl_complex, 0, free, z); *z = gsl_linalg_complex_LU_sgndet(mtmp, signum); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return vz; }
static VALUE rb_gsl_linalg_complex_LU_invert(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL, *inverse = NULL; gsl_permutation *p = NULL; int flagm = 0, signum, itmp; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 1; break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } itmp = 0; } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); } inverse = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_linalg_complex_LU_invert(mtmp, p, inverse); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, inverse); }
bool Matrix_Inverse(gsl_matrix_complex *A, gsl_matrix_complex *B){ int s; gsl_matrix_complex *T; gsl_permutation *p; T=gsl_matrix_complex_alloc(B->size1,B->size2); gsl_matrix_complex_memcpy(T, B); p=gsl_permutation_alloc (T->size1); gsl_linalg_complex_LU_decomp (T, p, &s); gsl_linalg_complex_LU_invert (T, p,A); gsl_permutation_free(p); gsl_matrix_complex_free(T); return true; }
static void *matrix_invert(void *m, bool complex) { int sign = 0; int size = ((gsl_matrix *)m)->size1; void *result; if (size != ((gsl_matrix *)m)->size2) return NULL; gsl_permutation *p = gsl_permutation_calloc(size); if (!complex) { gsl_matrix *tmp = gsl_matrix_alloc(size, size); result = gsl_matrix_alloc(size, size); gsl_matrix_memcpy(tmp, (gsl_matrix *)m); gsl_linalg_LU_decomp(tmp, p, &sign); if (gsl_linalg_LU_invert(tmp, p, (gsl_matrix *)result) != GSL_SUCCESS) { gsl_matrix_free(result); return NULL; } gsl_matrix_free(tmp); } else { gsl_matrix_complex *tmp = gsl_matrix_complex_alloc(size, size); result = gsl_matrix_complex_alloc(size, size); gsl_matrix_complex_memcpy(tmp, (gsl_matrix_complex *)m); gsl_linalg_complex_LU_decomp(tmp, p, &sign); if (gsl_linalg_complex_LU_invert(tmp, p, (gsl_matrix_complex *)result) != GSL_SUCCESS) { gsl_matrix_complex_free(result); return NULL; } gsl_matrix_complex_free(tmp); } gsl_permutation_free(p); return result; }
static VALUE rb_gsl_linalg_complex_LU_lndet(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; double lndet; int flagm = 0, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: CHECK_MATRIX_COMPLEX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } break; default: Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); flagm = 1; } else { mtmp = m; } } if (flagm == 1) { p = gsl_permutation_alloc(m->size1); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } lndet = gsl_linalg_complex_LU_lndet(mtmp); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } return rb_float_new(lndet); }
static int mc_inverse(lua_State *L) { mMatComplex *m = qlua_checkMatComplex(L, 1); mMatComplex *lu; mMatComplex *r; gsl_permutation *p; int signum; if (m->l_size != m->r_size) return luaL_error(L, "square matrix expected"); p = new_permutation(L, m->l_size); lu = qlua_newMatComplex(L, m->l_size, m->l_size); r = qlua_newMatComplex(L, m->l_size, m->l_size); gsl_matrix_complex_memcpy(lu->m, m->m); gsl_linalg_complex_LU_decomp(lu->m, p, &signum); if (gsl_linalg_complex_LU_invert(lu->m, p, r->m)) luaL_error(L, "matrix:inverse() failed"); gsl_permutation_free(p); return 1; }
static VALUE rb_gsl_linalg_complex_LU_solve(int argc, VALUE *argv, VALUE obj) { gsl_matrix_complex *m = NULL, *mtmp = NULL; gsl_permutation *p = NULL; gsl_vector_complex *b = NULL, *x = NULL; int flagm = 0, flagx = 0, itmp, signum; switch (TYPE(obj)) { case T_MODULE: case T_CLASS: case T_OBJECT: if (argc < 2 || argc > 4) rb_raise(rb_eArgError, "Usage: solve(m, b), solve(m, b, x), solve(lu, p, b), solve(lu, p, b, x)"); CHECK_MATRIX(argv[0]); Data_Get_Struct(argv[0], gsl_matrix_complex, m); if (CLASS_OF(argv[0]) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 1; break; default: if (argc < 1 || argc > 3) rb_raise(rb_eArgError, "Usage: LU_solve(b), LU_solve(p, b), LU_solve(b, x), solve(p, b, x)"); Data_Get_Struct(obj, gsl_matrix_complex, m); if (CLASS_OF(obj) != cgsl_matrix_complex_LU) { flagm = 1; mtmp = gsl_matrix_complex_alloc(m->size1, m->size2); gsl_matrix_complex_memcpy(mtmp, m); } else { mtmp = m; } itmp = 0; } if (flagm == 1) { if (itmp != argc-1) rb_raise(rb_eArgError, "Usage: m.LU_solve(b)"); Data_Get_Struct(argv[itmp], gsl_vector_complex, b); x = gsl_vector_complex_alloc(b->size); p = gsl_permutation_alloc(b->size); gsl_linalg_complex_LU_decomp(mtmp, p, &signum); } else { Data_Get_Struct(argv[itmp], gsl_permutation, p); itmp++; Data_Get_Struct(argv[itmp], gsl_vector_complex, b); itmp++; if (itmp == argc-1) { Data_Get_Struct(argv[itmp], gsl_vector_complex, x); flagx = 1; } else { x = gsl_vector_complex_alloc(m->size1); } } gsl_linalg_complex_LU_solve(mtmp, p, b, x); if (flagm == 1) { gsl_matrix_complex_free(mtmp); gsl_permutation_free(p); } if (flagx == 0) return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, x); else return argv[argc-1]; }
/** * C++ version of gsl_linalg_complex_LU_decomp(). * @param A A matrix * @param p A permutation * @param signum The sign of the permutation * @return Error code on failure */ inline int complex_LU_decomp( matrix_complex& A, permutation& p, int* signum ){ return gsl_linalg_complex_LU_decomp( A.get(), p.get(), signum ); }
double Calculator::getIntensity(double Q) { std::complex<double> cppf1, cppf2; gsl_complex alpha, beta; gsl_complex gslf1, gslf2; int s; double avFactor; cppf1 = m_sf1->F(0.0, 0.0, Q, m_energy); cppf2 = m_sf2->F(0.0, 0.0, Q, m_energy); gslf1 = gsl_complex_rect(cppf1.real(), cppf1.imag()); gslf2 = gsl_complex_rect(cppf2.real(), cppf2.imag()); avFactor = exp(-2.0 / m_N); alpha = gsl_complex_rect (1.0, 0.0); beta = gsl_complex_rect (0.0, 0.0); /*set vector F (scattering factors)*/ gsl_vector_complex_set(F, 0, gslf1); gsl_vector_complex_set(F, 1, gslf2); /*set vector conj(F) (scattering factors)*/ gsl_vector_complex_set(Fconj, 0, gsl_complex_conjugate(gslf1)); gsl_vector_complex_set(Fconj, 1, gsl_complex_conjugate(gslf2)); /*set exp matrix*/ setMatrixExp(m_Exp, Q); /*find W = P * Exp * Ps * conj(F) vector:*/ /* (1) W = alpha * Ps * conj(F) + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, W); /*printf("W(1):\n"); gsl_vector_complex_fprintf (stdout, W, "%g");*/ /* (2) W = alpha * Exp * tmp_vec + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Exp, W, beta, tmp_vec); /*printf("W(2):\n"); gsl_vector_complex_fprintf (stdout, tmp_vec, "%g");*/ /* (3) W = alpha * P * tmp_vec + beta * W */ gsl_blas_zgemv (CblasNoTrans, alpha, m_P, tmp_vec, beta, W); /*Find J0 = F.(Ps * conj(F)) */ gsl_blas_zgemv (CblasNoTrans, alpha, m_Ps, Fconj, beta, tmp_vec); gsl_blas_zdotu (F, tmp_vec, &J0); /*alpha = exp(-2 / N)*/ alpha = gsl_complex_rect (avFactor, 0.0); beta = gsl_complex_rect (0.0, 0.0); /*find T matrix: T = alpha * P * exp + beta * T*/ gsl_blas_zgemm (CblasNoTrans, CblasNoTrans, alpha, m_P, m_Exp, beta, T); /*printf("T:\n"); gsl_matrix_complex_fprintf (stdout, T, "%g");*/ /*Find Jns = F. (G * W) */ /*tmp_mat = I */ gsl_matrix_complex_set_identity (tmp_mat); /*tmp_mat = I - T */ gsl_matrix_complex_sub (tmp_mat, T); /*LU decomposition*/ gsl_linalg_complex_LU_decomp(tmp_mat, perm, &s); /*calculate product G * W = (I - T)^(-1) W directly using LU decomposition*/ gsl_linalg_complex_LU_solve (tmp_mat, perm, W, tmp_vec); /*calculate F.(G * W)*/ gsl_blas_zdotu (F, tmp_vec, &Jns); /*Find Js = F.(G^2 * (I - T^N) * W) however, this term should be negligible*/ /*result = N *(2 * Jns + J0) - Js */ alpha = gsl_complex_mul_real (Jns, 2.0 * avFactor); alpha = gsl_complex_add (alpha, J0); return m_N * m_I0 * GSL_REAL(alpha) * getPLGfactor(getTheta(Q)) + m_Ibg; }
void Spectrometer::countDispersion_BS(Medium &Osrodek, QString DataName, QProgressBar *Progress, int factor) { //lsfgerhla double a=Osrodek.itsBasis.getLatticeConstant(); double thickness=Osrodek.itsStructure.getThickness(); int RecVec=itsRecVectors; int k_prec=itsK_Precision; double wi=itsFrequencies[0]; double w_prec=itsFrequencies[1]; double wf=itsFrequencies[2]; int half=3*(2*RecVec+1)*(2*RecVec+1); int dimension=6*(2*RecVec+1)*(2*RecVec+1); int EigValStrNumber=6*(2*RecVec+1)*(2*RecVec+1); int EigValNumber=9*(2*RecVec+1)*(2*RecVec+1); std::ofstream plik; DataName="results/"+ DataName + ".dat"; QByteArray bytes = DataName.toAscii(); const char * CDataName = bytes.data(); plik.open(CDataName); //inicjalizacje wektorów i macierzy gsl_matrix *gammaA=gsl_matrix_calloc(dimension, dimension); gsl_matrix *gammaB=gsl_matrix_calloc(dimension, dimension); gsl_matrix *gammaC=gsl_matrix_calloc(dimension, dimension); gsl_matrix *gammaD=gsl_matrix_calloc(dimension, dimension); gsl_eigen_genv_workspace *wspce=gsl_eigen_genv_alloc(dimension); gsl_eigen_genv_workspace *wspce2=gsl_eigen_genv_alloc(dimension); gsl_vector_complex *StrAlpha =gsl_vector_complex_alloc(dimension); gsl_vector *StrBeta = gsl_vector_alloc(dimension); gsl_matrix_complex *StrEigenVec=gsl_matrix_complex_calloc(dimension, dimension); gsl_vector_complex *BAlpha =gsl_vector_complex_alloc(dimension); gsl_vector *BBeta = gsl_vector_alloc(dimension); gsl_matrix_complex *BasisEigenVec=gsl_matrix_complex_calloc(dimension, dimension); gsl_matrix_complex *ChosenVectors = gsl_matrix_complex_calloc(half, EigValNumber); gsl_vector_complex *ChosenValues = gsl_vector_complex_calloc(EigValNumber); gsl_matrix_complex *Boundaries=gsl_matrix_complex_calloc(EigValNumber, EigValNumber); double kx, ky, krokx, kroky, boundary_x, boundary_y; double k_zred, k_zred0; double krok = M_PI/(k_prec*a); for (int droga=0; droga<3; droga++) { //int droga = 1; if (droga==0) //droga M->Gamma { kx=-M_PI/a; krokx=krok; boundary_x=0; ky=-M_PI/a; kroky=krok; boundary_y=0; k_zred0=-1*sqrt(pow(kx/(2*M_PI/a), 2)+pow(ky/(2*M_PI/a), 2)); } else if (droga==1) { kx=0; //droga Gamma->X krokx=krok; boundary_x=M_PI/a; ky=0; kroky=0; boundary_y=0; k_zred0=sqrt(2)/2; //k_zred0=0; } else if (droga==2) { kx=M_PI/a; //Droga X->M krokx=0; boundary_x=M_PI/a; ky=0; kroky=krok; boundary_y=M_PI/a; k_zred0=sqrt(2)/2; } //petla dla wektorów falowych for (; kx <= boundary_x && ky <= boundary_y; kx=kx+krokx, ky=ky+kroky) { if (droga==0) { k_zred = abs(k_zred0 + sqrt( pow(kx/(2*M_PI/a), 2)+pow(ky/(2*M_PI/a), 2))); } else { k_zred = k_zred0 + kx/(2*M_PI/a) + ky/(2*M_PI/a); } int postep=int(100*k_zred/1.7); Progress->setValue(postep); Progress->update(); QApplication::processEvents(); //pętla dla częstości w for (double w=wi; w<wf; w=w+w_prec) { gsl_matrix_complex_set_all(Boundaries, gsl_complex_rect (0,0)); //ustawienie wartosci wyznacznika na 0 gsl_matrix_set_all(gammaA, 0); gsl_matrix_set_all(gammaB, 0); gsl_matrix_set_all(gammaC, 0); gsl_matrix_set_all(gammaD, 0); gsl_vector_complex_set_all(StrAlpha, gsl_complex_rect (0,0)); gsl_vector_set_all(BBeta, 0); gsl_vector_complex_set_all(BAlpha, gsl_complex_rect (0,0)); gsl_vector_set_all(StrBeta, 0); gsl_matrix_complex_set_all(BasisEigenVec, gsl_complex_rect (0,0)); gsl_matrix_complex_set_all(StrEigenVec, gsl_complex_rect (0,0)); gsl_matrix_complex_set_all(ChosenVectors, gsl_complex_rect (0,0)); gsl_vector_complex_set_all(ChosenValues, gsl_complex_rect (0,0)); //gammaA,B dla struktury //gammaA,B dla struktury /* S - numeruje transformaty tensora sprężystoci i gestosci i - numeruje wiersze macierzy j - numeruje kolumny macierzy half - druga polowa macierzy */ for(int Nx=-RecVec, i=0, S=0; Nx<=RecVec; Nx++) { for(int Ny=-RecVec; Ny<=RecVec; Ny++, i=i+3) { for(int Nx_prim=-RecVec, j=0; Nx_prim<=RecVec; Nx_prim++) { for(int Ny_prim=-RecVec; Ny_prim<=RecVec; Ny_prim++, j=j+3, S++) { double Elasticity[6][6]; itsRecStructureSubstance[S].getElasticity(Elasticity); double Density=itsRecStructureSubstance[S].getDensity(); double gx=2*M_PI*Nx/a; double gy=2*M_PI*Ny/a; double gx_prim=2*M_PI*Nx_prim/a; double gy_prim=2*M_PI*Ny_prim/a; gsl_matrix_set(gammaA, i, j, Elasticity[3][3]); gsl_matrix_set(gammaA, i+1, j+1, Elasticity[3][3]); gsl_matrix_set(gammaA, i+2, j+2, Elasticity[0][0]); gsl_matrix_set(gammaB, i+2, j, -Elasticity[0][1]*(kx+gx_prim)-Elasticity[3][3]*(kx+gx)); gsl_matrix_set(gammaB, i+2, j+1, -Elasticity[0][1]*(ky+gy_prim)-Elasticity[3][3]*(ky+gy)); gsl_matrix_set(gammaB, i, j+2, -Elasticity[0][1]*(kx+gx)-Elasticity[3][3]*(kx+gx_prim)); gsl_matrix_set(gammaB, i+1, j+2, -Elasticity[0][1]*(ky+gy)-Elasticity[3][3]*(ky+gy_prim)); gsl_matrix_set(gammaB, i, j+half, -Elasticity[0][0]*(kx+gx)*(kx+gx_prim)-Elasticity[3][3]*(ky+gy)*(ky+gy_prim)+Density*w*w); gsl_matrix_set(gammaB, i+1, j+half, -Elasticity[0][1]*(kx+gx_prim)*(ky+gy)-Elasticity[3][3]*(ky+gy_prim)*(kx+gx)); gsl_matrix_set(gammaB, i, j+half+1, -Elasticity[0][1]*(ky+gy_prim)*(kx+gx)-Elasticity[3][3]*(kx+gx_prim)*(ky+gy)); gsl_matrix_set(gammaB, i+1, j+half+1, -Elasticity[0][0]*(ky+gy_prim)*(ky+gy)-Elasticity[3][3]*(kx+gx_prim)*(kx+gx)+Density*w*w); gsl_matrix_set(gammaB, i+2, j+half+2, -Elasticity[3][3]*(ky+gy_prim)*(ky+gy)-Elasticity[3][3]*(kx+gx_prim)*(kx+gx)+Density*w*w); if (i==j) { gsl_matrix_set(gammaA, i+half, j+half, 1); gsl_matrix_set(gammaA, i+half+1, j+half+1, 1); gsl_matrix_set(gammaA, i+half+2, j+half+2, 1); gsl_matrix_set(gammaB, i+half, j, 1); gsl_matrix_set(gammaB, i+half+1, j+1, 1); gsl_matrix_set(gammaB, i+half+2, j+2, 1); } } } } } //rozwiazanie zagadnienienia własnego gsl_eigen_genv(gammaB, gammaA, StrAlpha, StrBeta, StrEigenVec, wspce); //gammaC,D dla Podłoża for(int Nx=-RecVec, i=0, S=0; Nx<=RecVec; Nx++) { for(int Ny=-RecVec; Ny<=RecVec; Ny++, i=i+3) { for(int Nx_prim=-RecVec, j=0; Nx_prim<=RecVec; Nx_prim++) { for(int Ny_prim=-RecVec; Ny_prim<=RecVec; Ny_prim++, j=j+3, S++) { double Elasticity[6][6]; itsRecBasisSubstance[S].getElasticity(Elasticity); double Density=itsRecBasisSubstance[S].getDensity(); double gx=2*M_PI*Nx/a; double gy=2*M_PI*Ny/a; double gx_prim=2*M_PI*Nx_prim/a; double gy_prim=2*M_PI*Ny_prim/a; gsl_matrix_set(gammaC, i, j, Elasticity[3][3]); gsl_matrix_set(gammaC, i+1, j+1, Elasticity[3][3]); gsl_matrix_set(gammaC, i+2, j+2, Elasticity[0][0]); gsl_matrix_set(gammaD, i+2, j, -Elasticity[0][1]*(kx+gx_prim)-Elasticity[3][3]*(kx+gx)); gsl_matrix_set(gammaD, i+2, j+1, -Elasticity[0][1]*(ky+gy_prim)-Elasticity[3][3]*(ky+gy)); gsl_matrix_set(gammaD, i, j+2, -Elasticity[0][1]*(kx+gx)-Elasticity[3][3]*(kx+gx_prim)); gsl_matrix_set(gammaD, i+1, j+2, -Elasticity[0][1]*(ky+gy)-Elasticity[3][3]*(ky+gy_prim)); gsl_matrix_set(gammaD, i, j+half, -Elasticity[0][0]*(kx+gx)*(kx+gx_prim)-Elasticity[3][3]*(ky+gy)*(ky+gy_prim)+Density*w*w); gsl_matrix_set(gammaD, i+1, j+half, -Elasticity[0][1]*(kx+gx_prim)*(ky+gy)-Elasticity[3][3]*(ky+gy_prim)*(kx+gx)); gsl_matrix_set(gammaD, i, j+half+1, -Elasticity[0][1]*(ky+gy_prim)*(kx+gx)-Elasticity[3][3]*(kx+gx_prim)*(ky+gy)); gsl_matrix_set(gammaD, i+1, j+half+1, -Elasticity[0][0]*(ky+gy_prim)*(ky+gy)-Elasticity[3][3]*(kx+gx_prim)*(kx+gx)+Density*w*w); gsl_matrix_set(gammaD, i+2, j+half+2, -Elasticity[3][3]*(ky+gy_prim)*(ky+gy)-Elasticity[3][3]*(kx+gx_prim)*(kx+gx)+Density*w*w); if (i==j) { gsl_matrix_set(gammaC, i+half, j+half, 1); gsl_matrix_set(gammaC, i+half+1, j+half+1, 1); gsl_matrix_set(gammaC, i+half+2, j+half+2, 1); gsl_matrix_set(gammaD, i+half, j, 1); gsl_matrix_set(gammaD, i+half+1, j+1, 1); gsl_matrix_set(gammaD, i+half+2, j+2, 1); } } } } } //rozwiazanie zagadnienienia własnego gsl_eigen_genv(gammaD, gammaC, BAlpha, BBeta, BasisEigenVec, wspce2); double imagL, realL; //części Re i Im wartości własnych int n=0; for (int i = 0; i<dimension; i++) { //przepisanie wartości i wektorów własnych struktury do macierzy Chosen* gsl_complex StrValue; StrValue= gsl_complex_div_real(gsl_vector_complex_get(StrAlpha, i), gsl_vector_get(StrBeta,i)); gsl_vector_complex_set(ChosenValues, i, StrValue); for (int j = half, m=0; j < dimension; j++, m++) { gsl_matrix_complex_set(ChosenVectors, m, i, gsl_matrix_complex_get(StrEigenVec, j, i)); } //wybieranie odpowiednich wartości i wektorów własnych dla podłoża i przepisanie do macierzy Chosen* gsl_complex BValue; BValue= gsl_complex_div_real(gsl_vector_complex_get(BAlpha, i), gsl_vector_get(BBeta,i)); imagL=GSL_IMAG(BValue); realL=GSL_REAL(BValue); if (imagL > 0.00001 && n+EigValStrNumber<EigValNumber) //warunek na wartości własne && żeby nie było ich więcej niż połowa { gsl_vector_complex_set(ChosenValues, n+EigValStrNumber, BValue); //wybranie wartości własnej for (int j = half, m=0; j < dimension; j++, m++) { gsl_matrix_complex_set(ChosenVectors, m, n+EigValStrNumber, gsl_complex_mul_real(gsl_matrix_complex_get(BasisEigenVec, j, i), -1)); //wybranie drugiej połowy wektora własnego } n++; } } if (n+EigValStrNumber<EigValNumber) { for (int i = 0; i<dimension; i++) { gsl_complex BValue; BValue= gsl_complex_div_real(gsl_vector_complex_get(BAlpha, i), gsl_vector_get(BBeta,i)); imagL=GSL_IMAG(BValue); realL=GSL_REAL(BValue); if (imagL < 0.00001 && imagL > -0.00001 && realL < -0.00001 && n+EigValStrNumber<EigValNumber) //warunek na wartości własne && żeby nie było ich więcej niż połowa { gsl_vector_complex_set(ChosenValues, n+EigValStrNumber, BValue); //wybranie wartości własnej for (int j = half, m=0; j < dimension; j++, m++) { gsl_matrix_complex_set(ChosenVectors, m, n+EigValStrNumber, gsl_complex_mul_real(gsl_matrix_complex_get(BasisEigenVec, j, i), -1)); //wybranie drugiej połowy wektora własnego } n++; } } } //wyznacznik warunków brzegowych - konstrukcja /* S, S' - numerujš transformaty tensora sprężystoci i - numeruje wektory własne A w pętli dla G j - numeruje warunki brzegowe dla kolejnych wektorow odwrotnych G k - numeruje wektory własne A w pętli dla G' L - numeruje wartoci własne */ for (int Nx=-RecVec, S=0, S_prim=0, i=0, j=0; Nx <= RecVec; Nx++) { for (int Ny=-RecVec; Ny <= RecVec; Ny++, j=j+9, i=i+3) { for (int L=0; L < EigValNumber; L++) { S_prim = S; for (int Nx_prim=-RecVec, k=0; Nx_prim <= RecVec; Nx_prim++) { for (int Ny_prim=-RecVec; Ny_prim <= RecVec; Ny_prim++, S_prim++, k=k+3) { double StrElasticity[6][6]; itsRecStructureSubstance[S_prim].getElasticity(StrElasticity); double BasisElasticity[6][6]; itsRecBasisSubstance[S_prim].getElasticity(BasisElasticity); double gx_prim=2*M_PI*Nx_prim/a; double gy_prim=2*M_PI*Ny_prim/a; if (L < EigValStrNumber) { //eksponens gsl_complex exponent = gsl_complex_polar(exp(GSL_IMAG(gsl_vector_complex_get(ChosenValues, L))*thickness), -1*GSL_REAL(gsl_vector_complex_get(ChosenValues, L))*thickness); //warunki zerowania się naprężenia na powierzchni gsl_complex w1 = gsl_complex_mul_real(exponent, StrElasticity[3][3]); gsl_complex w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (kx+gx_prim)); gsl_complex w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k, L)); gsl_complex BCjL = gsl_complex_add(gsl_complex_mul(gsl_complex_add(w2, w3), w1), gsl_matrix_complex_get(Boundaries, j, L)); gsl_matrix_complex_set(Boundaries, j, L, BCjL); w1 = gsl_complex_mul_real(exponent, StrElasticity[3][3]); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+1, L)); BCjL = gsl_complex_add(gsl_complex_mul(gsl_complex_add(w2, w3), w1), gsl_matrix_complex_get(Boundaries, j+1, L)); gsl_matrix_complex_set(Boundaries, j+1, L, BCjL); w1 = gsl_complex_mul_real(exponent, StrElasticity[0][0]); gsl_complex w11 = gsl_complex_mul_real(exponent, StrElasticity[0][1]); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k, L), (kx+gx_prim)); gsl_complex w22 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+1, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+2, L)); gsl_complex w4 = gsl_complex_add(gsl_complex_mul(gsl_complex_add(w2, w22), w11), gsl_complex_mul(w3, w1)); BCjL = gsl_complex_add(w4, gsl_matrix_complex_get(Boundaries, j+2, L)); gsl_matrix_complex_set(Boundaries, j+2, L, BCjL); //warunki równości naprężeń na granicy ośrodków - część dla struktury w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (kx+gx_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k, L)); BCjL = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w3), StrElasticity[3][3]), gsl_matrix_complex_get(Boundaries, j+3, L)); gsl_matrix_complex_set(Boundaries, j+3, L, BCjL); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+1, L)); BCjL = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w3), StrElasticity[3][3]), gsl_matrix_complex_get(Boundaries, j+4, L)); gsl_matrix_complex_set(Boundaries, j+4, L, BCjL); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k, L), (kx+gx_prim)); w22 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+1, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+2, L)); w4 = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w22), StrElasticity[0][1]), gsl_complex_mul_real(w3, StrElasticity[0][0])); BCjL = gsl_complex_add(w4, gsl_matrix_complex_get(Boundaries, j+5, L)); gsl_matrix_complex_set(Boundaries, j+5, L, BCjL); } else { //warunki równości naprężeń na granicy ośrodków - część dla podłoża gsl_complex w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (kx+gx_prim)); gsl_complex w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k, L)); gsl_complex BCjL = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w3), BasisElasticity[3][3]), gsl_matrix_complex_get(Boundaries, j+3, L)); gsl_matrix_complex_set(Boundaries, j+3, L, BCjL); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+2, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+1, L)); BCjL = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w3), BasisElasticity[3][3]), gsl_matrix_complex_get(Boundaries, j+4, L)); gsl_matrix_complex_set(Boundaries, j+4, L, BCjL); w2 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k, L), (kx+gx_prim)); gsl_complex w22 = gsl_complex_mul_real(gsl_matrix_complex_get(ChosenVectors, k+1, L), (ky+gy_prim)); w3 = gsl_complex_mul(gsl_vector_complex_get(ChosenValues, L), gsl_matrix_complex_get(ChosenVectors, k+2, L)); gsl_complex w4 = gsl_complex_add(gsl_complex_mul_real(gsl_complex_add(w2, w22), BasisElasticity[0][1]), gsl_complex_mul_real(w3, BasisElasticity[0][0])); BCjL = gsl_complex_add(w4, gsl_matrix_complex_get(Boundaries, j+5, L)); gsl_matrix_complex_set(Boundaries, j+5, L, BCjL); } } } // warunek równości wychyleń na granicy ośrodków gsl_matrix_complex_set(Boundaries, j+6, L, gsl_matrix_complex_get(ChosenVectors, i, L)); gsl_matrix_complex_set(Boundaries, j+7, L, gsl_matrix_complex_get(ChosenVectors, i+1, L)); gsl_matrix_complex_set(Boundaries, j+8, L, gsl_matrix_complex_get(ChosenVectors, i+2, L)); } S=S_prim; } } //skalowanie macierzy Boundaries gsl_complex scale=gsl_complex_rect(pow(10, factor), 0); gsl_matrix_complex_scale(Boundaries, scale); //obliczenie wyznacznika z Boundaries gsl_permutation *Bpermutation = gsl_permutation_alloc(EigValNumber); int Bsignum; gsl_linalg_complex_LU_decomp(Boundaries, Bpermutation, &Bsignum); double DetVal = gsl_linalg_complex_LU_lndet(Boundaries); //usuwanie NaN if(DetVal != DetVal) DetVal = 0; //zapisanie wartości do pliku plik << k_zred << "\t" << w << "\t" << DetVal << "\n"; } plik << "\n"; } } plik.close(); gsl_matrix_free(gammaA); gsl_matrix_free(gammaB); gsl_vector_free(BBeta); gsl_vector_free(StrBeta); gsl_matrix_free(gammaC); gsl_matrix_free(gammaD); gsl_vector_complex_free(StrAlpha); gsl_vector_complex_free(BAlpha); gsl_eigen_genv_free(wspce); gsl_eigen_genv_free(wspce2); gsl_matrix_complex_free(Boundaries); gsl_matrix_complex_free(ChosenVectors); gsl_vector_complex_free(ChosenValues); }