/* psi(z) for large |z| in the right half-plane; [Abramowitz + Stegun, 6.3.18] */
static
gsl_complex
psi_complex_asymp(gsl_complex z)
{
/* coefficients in the asymptotic expansion for large z;
* let w = z^(-2) and write the expression in the form
*
* ln(z) - 1/(2z) - 1/12 w (1 + c1 w + c2 w + c3 w + ... )
*/
static const double c1 = -0.1;
static const double c2 = 1.0/21.0;
static const double c3 = -0.05;
gsl_complex zi = gsl_complex_inverse(z);
gsl_complex w = gsl_complex_mul(zi, zi);
gsl_complex cs;
/* Horner method evaluation of term in parentheses */
gsl_complex sum;
sum = gsl_complex_mul_real(w, c3/c2);
sum = gsl_complex_add_real(sum, 1.0);
sum = gsl_complex_mul_real(sum, c2/c1);
sum = gsl_complex_mul(sum, w);
sum = gsl_complex_add_real(sum, 1.0);
sum = gsl_complex_mul_real(sum, c1);
sum = gsl_complex_mul(sum, w);
sum = gsl_complex_add_real(sum, 1.0);
/* correction added to log(z) */
cs = gsl_complex_mul(sum, w);
cs = gsl_complex_mul_real(cs, -1.0/12.0);
cs = gsl_complex_add(cs, gsl_complex_mul_real(zi, -0.5));
return gsl_complex_add(gsl_complex_log(z), cs);
}
gsl_complex
gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU, int signum)
{
size_t i, n = LU->size1;
gsl_complex phase = gsl_complex_rect((double) signum, 0.0);
for (i = 0; i < n; i++)
{
gsl_complex z = gsl_matrix_complex_get (LU, i, i);
double r = gsl_complex_abs(z);
if (r == 0)
{
phase = gsl_complex_rect(0.0, 0.0);
break;
}
else
{
z = gsl_complex_div_real(z, r);
phase = gsl_complex_mul(phase, z);
}
}
return phase;
}
void expm(gsl_matrix_complex * L, gsl_complex t, gsl_matrix * m)
{
int i,j,s;
gsl_vector_complex *eval = gsl_vector_complex_alloc(4);
gsl_matrix_complex *evec = gsl_matrix_complex_alloc(4, 4);
gsl_eigen_nonsymmv_workspace * w = gsl_eigen_nonsymmv_alloc(4);
gsl_matrix_complex *evalmat = gsl_matrix_complex_alloc(4, 4);
gsl_matrix_complex *vd = gsl_matrix_complex_alloc(4, 4);
gsl_complex one = gsl_complex_rect(1, 0);
gsl_complex zero = gsl_complex_rect(0, 0);
gsl_matrix_complex *K = gsl_matrix_complex_alloc(4, 4);
gsl_permutation *p = gsl_permutation_alloc(4);
gsl_vector_complex *x = gsl_vector_complex_alloc(4);
gsl_vector_complex_view bp;
gsl_complex z;
gsl_eigen_nonsymmv(m, eval, evec, w);
gsl_eigen_nonsymmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
gsl_eigen_nonsymmv_free(w); // clear workspace
for (i = 0; i < 4; i++)
{
gsl_complex eval_i = gsl_vector_complex_get(eval, i);
gsl_complex expeval = gsl_complex_mul(eval_i,t);
expeval = gsl_complex_exp(expeval);
gsl_matrix_complex_set(evalmat, i, i, expeval);
}
gsl_vector_complex_free(eval); // clear vector for eigenvalues
// v'L'=De'v'
gsl_blas_zgemm(CblasTrans, CblasTrans, one, evalmat, evec, zero, vd);
gsl_matrix_complex_transpose(evec);//transpose v
gsl_matrix_complex_memcpy(K,evec);
for (i = 0; i < 4; i++)
{
bp = gsl_matrix_complex_column(vd, i);
gsl_linalg_complex_LU_decomp(evec, p, &s);
gsl_linalg_complex_LU_solve(evec, p, &bp.vector, x);
for (j = 0; j < 4; j++)
{
z = gsl_vector_complex_get(x, j);
gsl_matrix_complex_set(L,i,j,z); //'through the looking glass' transpose
}
gsl_matrix_complex_memcpy(evec,K);
}
gsl_permutation_free(p);
gsl_vector_complex_free(x);
gsl_matrix_complex_free(vd);
gsl_matrix_complex_free(evec);
gsl_matrix_complex_free(evalmat);
gsl_matrix_complex_free(K);
}
vectorc operator*(const gsl_complex n, const vectorc & vec)
{
vectorc result(vec.size_m);
for (int i=0; i<vec.size_m; i++)
gsl_vector_complex_set(result.v_m, i, gsl_complex_mul(n,gsl_vector_complex_get(vec.v_m,i)));
return result;
}
vectorc vectorc::operator*(const gsl_complex n) const
{
vectorc result(size_m);
for (int i=0; i<size_m; i++)
gsl_vector_complex_set(result.v_m, i, gsl_complex_mul(n,gsl_vector_complex_get(v_m,i)));
return result;
}
gsl_complex f_envelope(gsl_complex p, const Params *params)
{
double m = params->m;
gsl_complex env = gsl_complex_div(
p,
gsl_complex_sqrt(gsl_complex_add_real(gsl_complex_mul(p,p), m*m)));
if (params->smear)
{
gsl_complex sp = gsl_complex_mul_real(p, params->sigma);
env = gsl_complex_mul(env, gsl_complex_exp(gsl_complex_negative(gsl_complex_mul(sp, sp))));
}
return env;
}
gsl_complex vectorc::operator*(const vectorc& vec) const
{
gsl_complex result;
for (int i=0; i<size_m; i++)
gsl_complex_add(result, gsl_complex_mul(gsl_vector_complex_get(v_m, i), gsl_vector_complex_get(vec.v_m, i)));
return result;
}
gsl_complex f_integrand(gsl_complex p, const Params *params)
{
double r = params->r;
return gsl_complex_mul(
f_envelope(p, params),
gsl_complex_exp(gsl_complex_mul_imag(p, r)));
}
/*
In: tau (lattice parameter)
Out: g2 -> g[0]
g3 -> g[1]
*/
void compute_invariants(gsl_complex tau, gsl_complex *g)
{
gsl_complex q, q14;
gsl_complex t2,t3,t24,t34;
gsl_complex g3_term1, g3_term2;
gsl_complex g2, g3;
q = gsl_complex_exp(gsl_complex_mul_imag(tau,M_PI));
q14 = gsl_complex_exp(gsl_complex_mul_imag(tau,M_PI_4));
t2=theta20(q,q14);
t3=theta30(q);
t24 = pow4(t2);
t34 = pow4(t3);
g2 = gsl_complex_mul_real(gsl_complex_sub(gsl_complex_add(gsl_complex_mul(t24,t24),gsl_complex_mul(t34,t34)),gsl_complex_mul(t24,t34)),_CONST_43PI4);
g3_term1 = gsl_complex_add(gsl_complex_mul(t24,gsl_complex_mul(t24,t24)),gsl_complex_mul(t34,gsl_complex_mul(t34,t34)));
g3_term2 = gsl_complex_mul(gsl_complex_add(t24,t34),gsl_complex_mul(t24,t34));
g3 = gsl_complex_sub( gsl_complex_mul_real(g3_term1, _CONST_827PI6),
gsl_complex_mul_real(g3_term2, _CONST_49PI6) );
g[0] = g2;
g[1] = g3;
}
gsl_complex theta40(gsl_complex q)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.5,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_negative(gsl_complex_mul(q,q2));
gsl_complex qpower = gsl_complex_negative(q);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
accum = gsl_complex_add(accum, qpower);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(accum,2.0);
}
gsl_complex theta20(gsl_complex q, gsl_complex q14)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.0,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = q2;
gsl_complex qpower = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
accum = gsl_complex_add(accum, qpower);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(gsl_complex_mul(q14,accum),2.0);
}
gsl_complex theta3(gsl_complex z, gsl_complex q)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.5,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_mul(q,q2);
gsl_complex qpower = q;
gsl_complex term = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(qpower) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
term = gsl_complex_mul(qpower, gsl_complex_cos(gsl_complex_mul_real(z,2*(n+1))));
accum = gsl_complex_add(accum, term);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(accum,2.0);
}
gsl_complex theta1(gsl_complex z, gsl_complex q, gsl_complex q14)
{
int n=0;
gsl_complex accum = gsl_complex_rect(0.0,0.0);
gsl_complex q2 = gsl_complex_mul(q,q);
gsl_complex nextm = gsl_complex_negative(q2);
gsl_complex qpower = gsl_complex_rect(1.0,0.0);
gsl_complex term = gsl_complex_rect(1.0,0.0);
while ((gsl_complex_abs(term) > 2.0*GSL_DBL_EPSILON) && (n < THETA_ITER_MAX)) {
term = gsl_complex_mul(qpower, gsl_complex_sin(gsl_complex_mul_real(z,2*n+1)));
accum = gsl_complex_add(accum, term);
qpower = gsl_complex_mul(qpower, nextm);
nextm = gsl_complex_mul(nextm, q2);
n++;
}
if (n >= THETA_ITER_MAX)
return(gsl_complex_rect(0.0,0.0));
return gsl_complex_mul_real(gsl_complex_mul(q14,accum),2.0);
}
/******************************************************************************
* calc_I()
* Calculate the field intensity at an arbitrary point within layer
*
* Parameters
* ---------
*
* Returns
* -------
*
* Notes
* -----
* Note assume that 0 <= z <= d[j] (but we dont check that here)
* except for the base layer (j==0), in that case z <= 0
*
******************************************************************************/
double calc_I(int layer_idx, double z, ref_model *ref, angle_calc *ang_c, layer_calc *lay_c){
double I, k;
gsl_complex Ai, Ar, Ei, Er, g, phase_i, phase_r;
k = ref->k;
GSL_REAL(Ai) = ang_c->Re_Ai[layer_idx];
GSL_IMAG(Ai) = ang_c->Im_Ai[layer_idx];
GSL_REAL(Ar) = ang_c->Re_Ar[layer_idx];
GSL_IMAG(Ar) = ang_c->Im_Ar[layer_idx];
GSL_REAL(g) = ang_c->Re_g[layer_idx];
GSL_IMAG(g) = ang_c->Im_g[layer_idx];
// calculate Ei at z within layer j
// make sure z is neg for base layer
if (layer_idx == 0){
if (z > 0) z = -1.0*z;
} else {
if (z < 0) z = -1.0*z;
}
GSL_REAL(phase_i) = 0.0;
GSL_IMAG(phase_i) = 1.0*k*z;
phase_i = gsl_complex_exp( gsl_complex_mul(phase_i,g));
Ei = gsl_complex_mul(Ai,phase_i);
// calculate Er at z within layer j
if (layer_idx > 0) {
GSL_REAL(phase_r) = 0.0;
GSL_IMAG(phase_r) = -1.0*k*z;
phase_r = gsl_complex_exp( gsl_complex_mul(phase_r,g));
Er = gsl_complex_mul(Ar,phase_r);
} else {
GSL_REAL(phase_r) = 0.0;
GSL_IMAG(phase_r) = 0.0;
GSL_REAL(Er) = 0.0;
GSL_IMAG(Er) = 0.0;
}
I = gsl_complex_abs2(gsl_complex_add(Ei,Er));
return (I);
}
double intensita(gsl_complex A, gsl_complex B) {
// PROVVISORIO
//~ double intensita = (gsl_complex_abs2(A) + gsl_complex_abs2(B) )/(2*in.Z_st);
double intensita = gsl_complex_abs(gsl_complex_mul(gsl_complex_add(A,B) , gsl_complex_conjugate(gsl_complex_add(A,B))));
printf("I=%e\n",intensita);
#ifdef DEBUG
printf("|A|=%e\n",gsl_complex_abs(A));
printf("|B|=%e\n",gsl_complex_abs(B));
printf("intensita=%e\n",intensita);
#endif
return intensita;
}
gsl_complex complex_spinor::operator* (const complex_spinor & complex_spinor_param) const{
gsl_complex aux_UP;
gsl_complex aux_DOWN;
gsl_complex aux;
GSL_SET_COMPLEX(&aux_UP, 0, 0);
GSL_SET_COMPLEX(&aux_DOWN, 0, 0);
GSL_SET_COMPLEX(&aux, 0, 0);
int i;
int nSitios = this->_numSites;
for(i=0; i<nSitios ; i++){
aux_UP = gsl_complex_mul(gsl_complex_conjugate(complex_spinor_param.complex_spinor_get(i,UP)) ,this->complex_spinor_get(i,UP));
aux_DOWN = gsl_complex_mul(gsl_complex_conjugate(complex_spinor_param.complex_spinor_get(i,DOWN)),this->complex_spinor_get(i,DOWN));
aux=gsl_complex_add(aux, gsl_complex_add(aux_UP,aux_DOWN));
}
return aux;
}
/* The Lattes map */
gsl_complex P_doubler(gsl_complex p, const gsl_complex *g)
{
gsl_complex p2, p3;
gsl_complex num;
gsl_complex denom;
gsl_complex term;
p2 = gsl_complex_mul(p,p);
p3 = gsl_complex_mul(p2,p);
/* denom = 4p^3 - g2p - g3 */
denom = gsl_complex_sub(gsl_complex_mul_real(p3,4.0),
gsl_complex_add(gsl_complex_mul(p,g[0]),g[1]));
/* num = (p^2 + g2/4)^2 + 2g3p */
term = gsl_complex_add(p2,gsl_complex_mul_real(g[0],0.25));
num = gsl_complex_add(gsl_complex_mul(p,gsl_complex_mul_real(g[1],2.0)),
gsl_complex_mul(term,term));
return gsl_complex_div(num,denom);
}
void gtmiso(gsl_matrix_complex * Tiso, gsl_complex eiso, double k0, double eta, double diso)
{
double eta2 = pow(eta,2);
gsl_complex rb = gsl_complex_rect(eta2,0);
gsl_complex za = gsl_complex_sub_real(eiso,eta2);
gsl_complex qiso = gsl_complex_sqrt(za);
gsl_complex zb = gsl_complex_mul_real(qiso,k0);
gsl_complex zc = gsl_complex_mul_real(zb,diso);
gsl_complex zd = gsl_complex_div(rb,eiso);
gsl_complex carg = gsl_complex_cos(zc);
gsl_complex sarg = gsl_complex_sin(zc);
gsl_complex i = gsl_complex_rect(0,1);
gsl_complex one = gsl_complex_rect(1,0);
gsl_matrix_complex_set_zero(Tiso);
gsl_matrix_complex_set(Tiso,0,0,carg);
gsl_matrix_complex_set(Tiso,1,1,carg);
gsl_matrix_complex_set(Tiso,2,2,carg);
gsl_matrix_complex_set(Tiso,3,3,carg);
gsl_complex zd1 = gsl_complex_sub(one,zd);
gsl_complex zd2 = eiso;
gsl_complex zd3 = one;
gsl_complex zd4 = gsl_complex_sub_real(eiso,eta2);
gsl_complex zmult1 = gsl_complex_mul(zd1,i);
gsl_complex zmult2 = gsl_complex_mul(zd2,i);
gsl_complex zmult3 = gsl_complex_mul(zd3,i);
gsl_complex zmult4 = gsl_complex_mul(zd4,i);
gsl_complex zdiv1 = gsl_complex_div(zmult1,qiso);
gsl_complex zdiv2 = gsl_complex_div(zmult2,qiso);
gsl_complex zdiv3 = gsl_complex_div(zmult3,qiso);
gsl_complex zdiv4 = gsl_complex_div(zmult4,qiso);
gsl_complex zmult5 = gsl_complex_mul(zdiv1,sarg);
gsl_complex zmult6 = gsl_complex_mul(zdiv2,sarg);
gsl_complex zmult7 = gsl_complex_mul(zdiv3,sarg);
gsl_complex zmult8 = gsl_complex_mul(zdiv4,sarg);
gsl_matrix_complex_set(Tiso,0,1,zmult5);
gsl_matrix_complex_set(Tiso,1,0,zmult6);
gsl_matrix_complex_set(Tiso,2,3,zmult7);
gsl_matrix_complex_set(Tiso,3,2,zmult8);
}
double rpp(gsl_matrix_complex * M)
{
gsl_complex t11, t43, t41, t13, t33, t31, mul1, mul2, mul3, mul4, sub1, sub2, div1;
t11 = gsl_matrix_complex_get(M,0,0);
t43 = gsl_matrix_complex_get(M,3,2);
t41 = gsl_matrix_complex_get(M,3,0);
t13 = gsl_matrix_complex_get(M,0,2);
t33 = gsl_matrix_complex_get(M,2,2);
t31 = gsl_matrix_complex_get(M,2,0);
mul1 = gsl_complex_mul(t11,t43);
mul2 = gsl_complex_mul(t41,t13);
mul3 = gsl_complex_mul(t11,t33);
mul4 = gsl_complex_mul(t13,t31);
sub1 = gsl_complex_sub(mul1,mul2);
sub2 = gsl_complex_sub(mul3,mul4);
div1 = gsl_complex_div(sub1,sub2);
return gsl_complex_abs2(div1);
}
//go through all sets of Bethe rapidities and calculate g1 for all identical sets. return value is sum of all these terms.
gsl_complex exact_integrationDE(double orteins, double ortzwei, double** kEp_plusminus, int anzahl_sets, double** coeffoverlap)
{
//variables to make loop easily readable, could delete from final version
double c, Energie, Energieprime, normierung, normierungprime;
double k[N];
double kprime[N];//corresponds to primed Bethe rapidity set in papers
gsl_complex overlap, overlapprime, integral;
GSL_SET_COMPLEX(&integral, 0.0, 0.0);//sum of all values, technically no needed but good for quick check of initial shape of g1
int zaehler_integrale = 0;//counter of total sets of integrals
double Nminusone_fak = 1.0;//(N-1) factorial, see definition of integrals on restricted spatial domain
for(int j=1; j<=(N-1); j++)
Nminusone_fak = Nminusone_fak * ((double) j);
for(int zaehler_eigenstate = 0 ; zaehler_eigenstate < anzahl_sets; zaehler_eigenstate++){//loop over all Bethe rapidity sets
c = kEp_plusminus[zaehler_eigenstate][0];//interaction strength
for(int bb=0; bb<N; bb++)
k[bb]=kEp_plusminus[zaehler_eigenstate][bb+1];//Bethe rapidities
Energie = kEp_plusminus[zaehler_eigenstate][N+1];//energy
normierung=kEp_plusminus[zaehler_eigenstate][N+6];//norm
GSL_SET_COMPLEX(&overlap, coeffoverlap[zaehler_eigenstate][0], coeffoverlap[zaehler_eigenstate][1]);//overlap of set with initial state
//calculate g1_DE for this Bethe set
gsl_complex integralwert = integraleigenfunction(k, k, c, normierung, normierung, orteins, ortzwei);
integralwert = gsl_complex_mul_real(integralwert, (Nminusone_fak*Laenge));//integral evaluated in Rp only -> missing factor of (N-1)!. Laenge (=system length): definition of g1 has prefactor of N!/(n*(N-1)!) = Laenge
integral = gsl_complex_add(integral, gsl_complex_mul(gsl_complex_mul(overlap, gsl_complex_conjugate(overlap)), integralwert));
}//end for loop zaehler_eigenstate
return integral;
};
/* NOTE: Assumes z is in fundamental parallelogram */
gsl_complex wP(gsl_complex z, gsl_complex tau, const gsl_complex *g)
{
int N = 6;
int i;
gsl_complex z0;
gsl_complex z02;
gsl_complex p;
z = near_origin(z,tau);
z0 = gsl_complex_div_real(z,(double)(1 << N));
z02 = gsl_complex_mul(z0,z0);
/* Laurent expansion: P \approx 1/z^2 + (g2/20)z^2 + (g3/28) z^4 */
p = gsl_complex_add(gsl_complex_inverse(z02),
gsl_complex_add(gsl_complex_mul(z02,gsl_complex_mul_real(g[0],0.05)),
gsl_complex_mul(gsl_complex_mul(z02,z02),gsl_complex_mul_real(g[1],_CONST_1_28))));
for (i=0;i<N;i++) {
p = P_doubler(p,g);
}
return p;
}
int extmat(gsl_matrix_complex * Lf, double nf, gsl_complex cphif)
{
gsl_matrix_complex_set_zero(Lf);
gsl_complex znf = gsl_complex_rect(nf,0);
gsl_complex zk = gsl_complex_mul(znf,cphif);
gsl_complex one = gsl_complex_rect(1,0);
gsl_matrix_complex_set(Lf,0,2,cphif);
gsl_matrix_complex_set(Lf,1,2,znf);
gsl_matrix_complex_set(Lf,2,0,one);
gsl_matrix_complex_set(Lf,3,0,zk);
return 1;
}
gsl_complex
gsl_linalg_complex_LU_det (gsl_matrix_complex * LU, int signum)
{
size_t i, n = LU->size1;
gsl_complex det = gsl_complex_rect((double) signum, 0.0);
for (i = 0; i < n; i++)
{
gsl_complex zi = gsl_matrix_complex_get (LU, i, i);
det = gsl_complex_mul (det, zi);
}
return det;
}
gsl_complex pspace(double x=0.00){
//La funcion de onda en el espacio p
// x aqui es un momento
//heredamos todo de coherentstate
gsl_complex result;
result=gsl_complex_rect(0.00,0.000);
for(int i=0; i<totals; i++){
result=
gsl_complex_add(result,
gsl_complex_mul(componente[i].pspace(x),pesos[i]));
};
return result;
};
int main(int argc, char** argv)
{
gsl_complex a,b;
GSL_SET_COMPLEX(&a,3,4);//a=3+4i
GSL_SET_COMPLEX(&b,6,8);//b=6+8i
gsl_complex c = gsl_complex_add(a,b);
printf("a+b\treal : %f image : %f\n",c.dat[0],c.dat[1]);
c = gsl_complex_sub(a,b);
printf("a-b\treal : %f image : %f\n",c.dat[0],c.dat[1]);
c = gsl_complex_mul(a,b);
printf("a*b\treal : %f image : %f\n",c.dat[0],c.dat[1]);
c = gsl_complex_div(a,b);
printf("a/b\treal : %f image : %f\n",c.dat[0],c.dat[1]);
// system("PAUSE");
return 0;
}
/* The extended Lattes map (rational function doubling on the elliptic curve) */
void P_and_Pprime_doubler(gsl_complex *p, gsl_complex *pp, const gsl_complex *g)
{
gsl_complex pp3;
gsl_complex ppp, ppp3;
/* p'' */
ppp = gsl_complex_sub(gsl_complex_mul_real(gsl_complex_mul(*p,*p),6.0),
gsl_complex_mul_real(g[0],0.5));
ppp3 = gsl_complex_mul(ppp,gsl_complex_mul(ppp,ppp));
pp3 = gsl_complex_mul(*pp,gsl_complex_mul(*pp,*pp));
*pp = gsl_complex_sub(gsl_complex_add(gsl_complex_mul_real(gsl_complex_div(gsl_complex_mul(*p,ppp),*pp),3.0),
gsl_complex_mul_real(gsl_complex_div(ppp3,pp3),-0.25)),
*pp);
*p = P_doubler(*p,g);
}
void Spectrometer::countAmplitudes_bulk_B(Medium &Osrodek, QString DataName, QProgressBar *Progress, QTextBrowser *Browser, double kx, double ky, double w, int polarisation, double x_lenght, double y_lenght, double precision) {
double a=Osrodek.itsBasis.getLatticeConstant();
int RecVec=itsRecVectors;
int dimension=3*(2*RecVec+1)*(2*RecVec+1);
std::ofstream plik;
DataName="results/amplitudes/"+ DataName + ".dat";
QByteArray bytes = DataName.toAscii();
const char * CDataName = bytes.data();
plik.open(CDataName);
//inicjalizacje wektorów i macierzy
gsl_matrix *gamma=gsl_matrix_calloc(dimension, dimension);
gsl_matrix *V=gsl_matrix_calloc(dimension, dimension);
gsl_vector *S=gsl_vector_calloc(dimension);
gsl_vector *work=gsl_vector_calloc(dimension);
//gamma dla Podłoża
/*
S - numeruje transformaty tensora sprężystoci i gestosci
i - numeruje wiersze macierzy
j - numeruje kolumny 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];
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(gamma, i, j, Elasticity[0][0]*(kx+gx)*(kx+gx_prim)+Elasticity[3][3]*(ky+gy)*(ky+gy_prim)-Density*w*w);
gsl_matrix_set(gamma, i+1, j, Elasticity[0][1]*(kx+gx_prim)*(ky+gy)+Elasticity[3][3]*(ky+gy_prim)*(kx+gx));
gsl_matrix_set(gamma, i, j+1, Elasticity[0][1]*(ky+gy_prim)*(kx+gx)+Elasticity[3][3]*(kx+gx_prim)*(ky+gy));
gsl_matrix_set(gamma, i+1, j+1, Elasticity[0][0]*(ky+gy_prim)*(ky+gy)+Elasticity[3][3]*(kx+gx_prim)*(kx+gx)-Density*w*w);
gsl_matrix_set(gamma, i+2, j+2, Elasticity[3][3]*(ky+gy_prim)*(ky+gy)+Elasticity[3][3]*(kx+gx_prim)*(kx+gx)-Density*w*w);
}
}
}
}
//rozwiązanie układu równań
gsl_linalg_SV_decomp(gamma, V, S, work);
gsl_complex u;
double Gx, Gy;
if (polarisation==3) {
gsl_complex ux, uy, uz;
for(double x=0; x < x_lenght; x=x+precision) {
for(double y=0; y < y_lenght; y=y+precision) {
ux = gsl_complex_rect(0, 0);
uy = gsl_complex_rect(0, 0);
uz = gsl_complex_rect(0, 0);
//pasek postepu
int postep=int(100*x/x_lenght);
Progress->setValue(postep);
Progress->update();
QApplication::processEvents();
for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {
Gx=2*M_PI*Nx/a;
Gy=2*M_PI*Ny/a;
double Ax = gsl_matrix_get(V, i, dimension-1);
double Ay = gsl_matrix_get(V, i+1, dimension-1);
double Az = gsl_matrix_get(V, i+2, dimension-1);
gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
gsl_complex exp1 = gsl_complex_exp(expin1);
gsl_complex multiply = gsl_complex_mul_real(exp1, Ax);
ux = gsl_complex_add(ux, multiply);
expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
exp1 = gsl_complex_exp(expin1);
multiply = gsl_complex_mul_real(exp1, Ay);
uy = gsl_complex_add(uy, multiply);
expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
exp1 = gsl_complex_exp(expin1);
multiply = gsl_complex_mul_real(exp1, Az);
uz = gsl_complex_add(uz, multiply);
}
}
double U = sqrt(gsl_complex_abs(ux)*gsl_complex_abs(ux)+gsl_complex_abs(uy)*gsl_complex_abs(uy)+gsl_complex_abs(uz)*gsl_complex_abs(uz));
//zapisanie wartości do pliku
QString nazwa = Osrodek.itsBasis.getFillingSubstance().getName();
if(nazwa=="Air")
{
double rad=Osrodek.itsBasis.getRadius();
if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
{
plik << x << "\t" << y << "\t" << U << "\n";
}
} else {
plik << x << "\t" << y << "\t" << U << "\n";
}
}
plik << "\n";
}
} else if (polarisation==4) {
gsl_complex uxx, uxy, uxz, uyx, uyy, uyz, uzx, uzy, uzz;
double Uxx, Uxy, Uxz, Uyx, Uyy, Uyz, Uzx, Uzy, Uzz;
for(double x=0; x < x_lenght; x=x+precision) {
for(double y=0; y < y_lenght; y=y+precision) {
uxx = gsl_complex_rect(0, 0);
uxy = gsl_complex_rect(0, 0);
uxz = gsl_complex_rect(0, 0);
uyx = gsl_complex_rect(0, 0);
uyy = gsl_complex_rect(0, 0);
uyz = gsl_complex_rect(0, 0);
uzx = gsl_complex_rect(0, 0);
uzy = gsl_complex_rect(0, 0);
uzz = gsl_complex_rect(0, 0);
double rad=Osrodek.itsBasis.getRadius();
double Ela[6][6];
if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
{
Osrodek.itsBasis.getSubstance().getElasticity(Ela);
} else {
Osrodek.itsBasis.getFillingSubstance().getElasticity(Ela);
}
//pasek postepu
int postep=int(100*x/x_lenght);
Progress->setValue(postep);
Progress->update();
QApplication::processEvents();
for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {
Gx=2*M_PI*Nx/a;
Gy=2*M_PI*Ny/a;
double Ax = gsl_matrix_get(V, i, dimension-1);
double Ay = gsl_matrix_get(V, i+1, dimension-1);
double Az = gsl_matrix_get(V, i+2, dimension-1);
gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
gsl_complex exp1 = gsl_complex_exp(expin1);
gsl_complex multiply = gsl_complex_mul_real(exp1, Ax);
//uxx
gsl_complex multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
uxx = gsl_complex_add(uxx, multidiff);
//uxy
multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
uxy = gsl_complex_add(uxy, multidiff);
expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
exp1 = gsl_complex_exp(expin1);
//uy
multiply = gsl_complex_mul_real(exp1, Ay);
//uyx
multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
uyx = gsl_complex_add(uyx, multidiff);
//uyy
multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
uyy = gsl_complex_add(uyy, multidiff);
expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
exp1 = gsl_complex_exp(expin1);
multiply = gsl_complex_mul_real(exp1, Az);
//uzx
multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
uzx = gsl_complex_add(uzx, multidiff);
//uzy
multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
uzy = gsl_complex_add(uzy, multidiff);
}
}
Uxx=gsl_complex_abs(uxx);
Uxy=gsl_complex_abs(uxy);
Uxz=gsl_complex_abs(uxz);
Uyx=gsl_complex_abs(uyx);
Uyy=gsl_complex_abs(uyy);
Uyz=gsl_complex_abs(uyz);
Uzx=gsl_complex_abs(uzx);
Uzy=gsl_complex_abs(uzy);
Uzz=gsl_complex_abs(uzz);
double U = Ela[0][0]*(Uxx*Uxx+Uyy*Uyy+Uzz*Uzz)+2*Ela[0][1]*(Uxx*Uyy+Uxx*Uzz+Uyy*Uzz)+0.25*Ela[3][3]*((Uyz+Uzy)*(Uyz+Uzy)+(Uxz+Uzx)*(Uxz+Uzx)+(Uxy+Uyx)*(Uxy+Uyx));
//zapisanie wartości do pliku
QString nazwa = Osrodek.itsBasis.getFillingSubstance().getName();
if(nazwa=="Air")
{
double rad=Osrodek.itsBasis.getRadius();
if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
{
plik << x << "\t" << y << "\t" << U << "\n";
}
} else {
plik << x << "\t" << y << "\t" << U << "\n";
}
}
plik << "\n";
}
} else {
for(double x=0; x < x_lenght; x=x+precision) {
for(double y=0; y < y_lenght; y=y+precision) {
u = gsl_complex_rect(0, 0);
//pasek postepu
int postep=int(100*x/x_lenght);
Progress->setValue(postep);
Progress->update();
QApplication::processEvents();
for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {
Gx=2*M_PI*Nx/a;
Gy=2*M_PI*Ny/a;
double A = gsl_matrix_get(V, i+polarisation, dimension-1);
gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
gsl_complex exp1 = gsl_complex_exp(expin1);
gsl_complex multiply = gsl_complex_mul_real(exp1, A);
u = gsl_complex_add(u, multiply);
}
}
double U = gsl_complex_abs(u);
//zapisanie wartości do pliku
plik << x << "\t" << y << "\t" << U << "\n";
}
plik << "\n";
}
}
plik.close();
gsl_matrix_free(gamma);
gsl_matrix_free(V);
gsl_vector_free(S);
gsl_vector_free(work);
}
complex& complex::operator*=(const complex& z1)
{
_complex = gsl_complex_mul(_complex, z1._complex);
return *this;
}
int
gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A, gsl_permutation * p, int *signum)
{
if (A->size1 != A->size2)
{
GSL_ERROR ("LU decomposition requires square matrix", GSL_ENOTSQR);
}
else if (p->size != A->size1)
{
GSL_ERROR ("permutation length must match matrix size", GSL_EBADLEN);
}
else
{
const size_t N = A->size1;
size_t i, j, k;
*signum = 1;
gsl_permutation_init (p);
for (j = 0; j < N - 1; j++)
{
/* Find maximum in the j-th column */
gsl_complex ajj = gsl_matrix_complex_get (A, j, j);
double max = gsl_complex_abs (ajj);
size_t i_pivot = j;
for (i = j + 1; i < N; i++)
{
gsl_complex aij = gsl_matrix_complex_get (A, i, j);
double ai = gsl_complex_abs (aij);
if (ai > max)
{
max = ai;
i_pivot = i;
}
}
if (i_pivot != j)
{
gsl_matrix_complex_swap_rows (A, j, i_pivot);
gsl_permutation_swap (p, j, i_pivot);
*signum = -(*signum);
}
ajj = gsl_matrix_complex_get (A, j, j);
if (!(GSL_REAL(ajj) == 0.0 && GSL_IMAG(ajj) == 0.0))
{
for (i = j + 1; i < N; i++)
{
gsl_complex aij_orig = gsl_matrix_complex_get (A, i, j);
gsl_complex aij = gsl_complex_div (aij_orig, ajj);
gsl_matrix_complex_set (A, i, j, aij);
for (k = j + 1; k < N; k++)
{
gsl_complex aik = gsl_matrix_complex_get (A, i, k);
gsl_complex ajk = gsl_matrix_complex_get (A, j, k);
/* aik = aik - aij * ajk */
gsl_complex aijajk = gsl_complex_mul (aij, ajk);
gsl_complex aik_new = gsl_complex_sub (aik, aijajk);
gsl_matrix_complex_set (A, i, k, aik_new);
}
}
}
}
return GSL_SUCCESS;
}
}
complex complex::operator*(const complex& z1) const
{
gsl_complex rl = gsl_complex_mul(_complex, z1._complex);
return complex(rl);
}
