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);
}
