Esempio n. 1
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.06204772145560590e+000,
                                         -2.73739947598261200e-001 );
    tau[1] = lapack_make_complex_double( 1.80592137164058510e+000,
                                         3.47906702984828510e-001 );
    tau[2] = lapack_make_complex_double( 1.18182347104100290e+000,
                                         9.83331188043276350e-001 );
}
Esempio n. 2
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.50202643533856510e+000,
                                         7.57519577948184250e-001 );
    tau[1] = lapack_make_complex_double( 1.99434395125208420e+000,
                                         1.06207846265674820e-001 );
    tau[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                         0.00000000000000000e+000 );
}
Esempio n. 3
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.68853417115046050e+000,
                                         5.95715661427263620e-001 );
    tau[1] = lapack_make_complex_double( 1.93508854618282510e+000,
                                         3.54414179735646040e-001 );
    tau[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                         0.00000000000000000e+000 );
}
Esempio n. 4
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.41028421676675380e+000,
                                         4.67908404514893240e-001 );
    tau[1] = lapack_make_complex_double( 1.30242036943477490e+000,
                                         7.85332074252958030e-001 );
    tau[2] = lapack_make_complex_double( 1.09397371592308160e+000,
                                         -9.95574678623159850e-001 );
}
Esempio n. 5
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.12581379184436000e+000,
                                         1.61760589514177240e-001 );
    tau[1] = lapack_make_complex_double( 1.09905366916895430e+000,
                                         5.46859059846678370e-001 );
    tau[2] = lapack_make_complex_double( 1.13292565731157910e+000,
                                         -9.59054047896148680e-001 );
}
Esempio n. 6
0
static void init_w( lapack_int size, lapack_complex_double *w ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        w[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    w[0] = lapack_make_complex_double( -6.00042534294925110e+000,
                                       -6.99984337157039070e+000 );
    w[1] = lapack_make_complex_double( -5.00003345759696490e+000,
                                       2.00602716231651220e+000 );
    w[2] = lapack_make_complex_double( 7.99819451620824480e+000,
                                       -9.96365091392899080e-001 );
    w[3] = lapack_make_complex_double( 3.00226428433797170e+000,
                                       -3.99981869935322360e+000 );
}
Esempio n. 7
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 0.00000000000000000e+000,
                                         0.00000000000000000e+000 );
    tau[1] = lapack_make_complex_double( 1.09819823812611190e+000,
                                         5.15816216039656440e-001 );
    tau[2] = lapack_make_complex_double( 1.45515808833705250e+000,
                                         -2.65922977495843870e-001 );
    tau[3] = lapack_make_complex_double( 1.98987975280288490e+000,
                                         -1.41908685396276930e-001 );
}
Esempio n. 8
0
static void init_tau( lapack_int size, lapack_complex_double *tau ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        tau[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    tau[0] = lapack_make_complex_double( 1.31098102965600650e+000,
                                         -2.62390243772255500e-001 );
    tau[1] = lapack_make_complex_double( 1.79648094914538530e+000,
                                         -2.34123857265783640e-002 );
    tau[2] = lapack_make_complex_double( 1.24204300792801540e+000,
                                         -1.80734862909935150e-001 );
    tau[3] = lapack_make_complex_double( 1.01439652256044810e+000,
                                         6.22528921213011400e-001 );
}
Esempio n. 9
0
static PyObject * py_phonopy_zheev(PyObject *self, PyObject *args)
{
  PyArrayObject* dynamical_matrix;
  PyArrayObject* eigenvalues;

  if (!PyArg_ParseTuple(args, "OO",
			&dynamical_matrix,
			&eigenvalues)) {
    return NULL;
  }

  const int dimension = (int)dynamical_matrix->dimensions[0];
  npy_cdouble *dynmat = (npy_cdouble*)dynamical_matrix->data;
  double *eigvals = (double*)eigenvalues->data;

  lapack_complex_double *a;
  int i, info;

  a = (lapack_complex_double*) malloc(sizeof(lapack_complex_double) *
				      dimension * dimension);
  for (i = 0; i < dimension * dimension; i++) {
    a[i] = lapack_make_complex_double(dynmat[i].real, dynmat[i].imag);
  }

  info = phonopy_zheev(eigvals, a, dimension, 'L');

  for (i = 0; i < dimension * dimension; i++) {
    dynmat[i].real = lapack_complex_double_real(a[i]);
    dynmat[i].imag = lapack_complex_double_imag(a[i]);
  }

  free(a);
  
  return PyLong_FromLong((long) info);
}
Esempio n. 10
0
lapack_complex_double get_phase_factor(const double q[],
				       const Darray *shortest_vectors,
				       const Iarray *multiplicity,
				       const int pi0,
				       const int si,
				       const int qi)
{
  int i, j, multi;
  double *svecs;
  double sum_real, sum_imag, phase;

  svecs = shortest_vectors->data + (si * shortest_vectors->dims[1] *
				    shortest_vectors->dims[2] * 3 +
				    pi0 * shortest_vectors->dims[2] * 3);
  multi = multiplicity->data[si * multiplicity->dims[1] + pi0];

  sum_real = 0;
  sum_imag = 0;
  for (i = 0; i < multi; i++) {
    phase = 0;
    for (j = 0; j < 3; j++) {
      phase += q[qi * 3 + j] * svecs[i * 3 + j];
    }
    sum_real += cos(M_2PI * phase);
    sum_imag += sin(M_2PI * phase);
  }
  sum_real /= multi;
  sum_imag /= multi;

  return lapack_make_complex_double(sum_real, sum_imag);
}
Esempio n. 11
0
lapack_complex_double
phonoc_complex_prod(const lapack_complex_double a,
		    const lapack_complex_double b)
{
  lapack_complex_double c;
  c = lapack_make_complex_double
    (lapack_complex_double_real(a) * lapack_complex_double_real(b) -
     lapack_complex_double_imag(a) * lapack_complex_double_imag(b),
     lapack_complex_double_imag(a) * lapack_complex_double_real(b) +
     lapack_complex_double_real(a) * lapack_complex_double_imag(b));
  return c;
}
Esempio n. 12
0
static lapack_complex_double fc3_sum_in_reciprocal_to_normal
(const int bi0,
 const int bi1,
 const int bi2,
 const lapack_complex_double *eigvecs0,
 const lapack_complex_double *eigvecs1,
 const lapack_complex_double *eigvecs2,
 const lapack_complex_double *fc3_reciprocal,
 const double *masses,
 const int num_atom)
{
  int i, j, k, l, m, n, index_l, index_lm, baseIndex;
  double sum_real, sum_imag, mmm, mass_l, mass_lm;
  lapack_complex_double eig_prod, eig_prod1;

  sum_real = 0;
  sum_imag = 0;

  for (l = 0; l < num_atom; l++) {
    mass_l = masses[l];
    index_l = l * num_atom * num_atom * 27;

    for (m = 0; m < num_atom; m++) {
      mass_lm = mass_l * masses[m];
      index_lm = index_l + m * num_atom * 27;

      for (i = 0; i < 3; i++) {
	for (j = 0; j < 3; j++) {
	  eig_prod1 = phonoc_complex_prod
	    (eigvecs0[(l * 3 + i) * num_atom * 3 + bi0],
	     eigvecs1[(m * 3 + j) * num_atom * 3 + bi1]);

	  for (n = 0; n < num_atom; n++) {
	    mmm = 1.0 / sqrt(mass_lm * masses[n]);
	    baseIndex = index_lm + n * 27 + i * 9 + j * 3;

	    for (k = 0; k < 3; k++) {
	      eig_prod = phonoc_complex_prod
		(eig_prod1, eigvecs2[(n * 3 + k) * num_atom * 3 + bi2]);
	      eig_prod = phonoc_complex_prod
		(eig_prod, fc3_reciprocal[baseIndex + k]);
	      sum_real += lapack_complex_double_real(eig_prod) * mmm;
	      sum_imag += lapack_complex_double_imag(eig_prod) * mmm;
	    }
	  }
	}
      }
    }
  }
  return lapack_make_complex_double(sum_real, sum_imag);
}
Esempio n. 13
0
/* Auxiliary functions: zunmbr array parameters initialization */
static void init_a( lapack_int size, lapack_complex_double *a ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        a[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    a[0] = lapack_make_complex_double( 2.76147559450819460e+000,
                                       0.00000000000000000e+000 );
    a[8] = lapack_make_complex_double( -9.49951456547741380e-001,
                                       0.00000000000000000e+000 );
    a[16] = lapack_make_complex_double( 7.65166949226434580e-002,
                                        -2.17935443626822770e-001 );
    a[1] = lapack_make_complex_double( -1.64579393401745320e-001,
                                       -2.48337744494629700e-001 );
    a[9] = lapack_make_complex_double( 1.62976302139712790e+000,
                                       0.00000000000000000e+000 );
    a[17] = lapack_make_complex_double( -1.01828100869306870e+000,
                                        0.00000000000000000e+000 );
    a[2] = lapack_make_complex_double( -2.07233441817599270e-004,
                                       1.36801102048543760e-001 );
    a[10] = lapack_make_complex_double( 2.64916983670861250e-001,
                                        -2.63261863195891070e-001 );
    a[18] = lapack_make_complex_double( -1.32748674289424410e+000,
                                        0.00000000000000000e+000 );
}
Esempio n. 14
0
/* Auxiliary functions: zungbr array parameters initialization */
static void init_a( lapack_int size, lapack_complex_double *a ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        a[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    a[0] = lapack_make_complex_double( -2.22551117723546850e+000,
                                       0.00000000000000000e+000 );
    a[8] = lapack_make_complex_double( -2.68747352747833510e-001,
                                       -2.74920472890458840e-001 );
    a[16] = lapack_make_complex_double( 2.45052968010876370e-001,
                                        4.65729785654097010e-001 );
    a[1] = lapack_make_complex_double( -1.63488453997962370e+000,
                                       0.00000000000000000e+000 );
    a[9] = lapack_make_complex_double( 1.60455842542666320e+000,
                                       0.00000000000000000e+000 );
    a[17] = lapack_make_complex_double( 4.32896662243069890e-001,
                                        -1.75807970570140830e-001 );
    a[2] = lapack_make_complex_double( -1.11366375782000860e-001,
                                       -2.21654174978857120e-001 );
    a[10] = lapack_make_complex_double( 9.91931214905034660e-001,
                                        0.00000000000000000e+000 );
    a[18] = lapack_make_complex_double( -1.67305626481148150e+000,
                                        0.00000000000000000e+000 );
}
Esempio n. 15
0
static void init_b( lapack_int size, lapack_complex_double *b ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        b[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    b[0] = lapack_make_complex_double( -1.06000000000000010e+000,
                                       2.15000000000000000e+001 );
    b[8] = lapack_make_complex_double( 1.28500000000000000e+001,
                                       2.83999999999999990e+000 );
    b[1] = lapack_make_complex_double( -2.27199999999999990e+001,
                                       -5.38999999999999990e+001 );
    b[9] = lapack_make_complex_double( -7.02199999999999990e+001,
                                       2.15700000000000000e+001 );
    b[2] = lapack_make_complex_double( 2.82399999999999980e+001,
                                       -3.86000000000000010e+001 );
    b[10] = lapack_make_complex_double( -2.07300000000000000e+001,
                                        -1.23000000000000000e+000 );
    b[3] = lapack_make_complex_double( -3.45600000000000020e+001,
                                       1.67300000000000000e+001 );
    b[11] = lapack_make_complex_double( 2.60100000000000020e+001,
                                        3.19699999999999990e+001 );
}
Esempio n. 16
0
static void init_x( lapack_int size, lapack_complex_double *x ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        x[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    x[0] = lapack_make_complex_double( -5.00000000000000000e+000,
                                       -2.00000000000000040e+000 );
    x[8] = lapack_make_complex_double( 1.00000000000000000e+000,
                                       5.00000000000000000e+000 );
    x[1] = lapack_make_complex_double( -2.99999999999999960e+000,
                                       -1.00000000000000000e+000 );
    x[9] = lapack_make_complex_double( -1.99999999999999960e+000,
                                       -2.00000000000000000e+000 );
    x[2] = lapack_make_complex_double( 1.99999999999999980e+000,
                                       1.00000000000000000e+000 );
    x[10] = lapack_make_complex_double( 2.99999999999999960e+000,
                                        4.00000000000000000e+000 );
    x[3] = lapack_make_complex_double( 4.00000000000000000e+000,
                                       2.99999999999999820e+000 );
    x[11] = lapack_make_complex_double( 3.99999999999999690e+000,
                                        -2.99999999999999910e+000 );
}
Esempio n. 17
0
static void init_b( lapack_int size, lapack_complex_double *b ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        b[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    b[0] = lapack_make_complex_double( -1.47799999999999990e+001,
                                       -3.23599999999999990e+001 );
    b[8] = lapack_make_complex_double( -1.80200000000000000e+001,
                                       2.84600000000000010e+001 );
    b[1] = lapack_make_complex_double( 2.98000000000000000e+000,
                                       -2.14000000000000010e+000 );
    b[9] = lapack_make_complex_double( 1.42200000000000010e+001,
                                       1.54200000000000000e+001 );
    b[2] = lapack_make_complex_double( -2.09600000000000010e+001,
                                       1.70599999999999990e+001 );
    b[10] = lapack_make_complex_double( 5.62000000000000010e+000,
                                        3.58900000000000010e+001 );
    b[3] = lapack_make_complex_double( 9.53999999999999910e+000,
                                       9.91000000000000010e+000 );
    b[11] = lapack_make_complex_double( -1.64600000000000010e+001,
                                        -1.73000000000000000e+000 );
}
Esempio n. 18
0
static void init_b( lapack_int size, lapack_complex_double *b ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        b[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    b[0] = lapack_make_complex_double( 3.93000000000000020e+000,
                                       -6.13999999999999970e+000 );
    b[8] = lapack_make_complex_double( 1.48000000000000000e+000,
                                       6.58000000000000010e+000 );
    b[1] = lapack_make_complex_double( 6.16999999999999990e+000,
                                       9.41999999999999990e+000 );
    b[9] = lapack_make_complex_double( 4.65000000000000040e+000,
                                       -4.75000000000000000e+000 );
    b[2] = lapack_make_complex_double( -7.16999999999999990e+000,
                                       -2.18299999999999980e+001 );
    b[10] = lapack_make_complex_double( -4.91000000000000010e+000,
                                        2.29000000000000000e+000 );
    b[3] = lapack_make_complex_double( 1.99000000000000000e+000,
                                       -1.43800000000000010e+001 );
    b[11] = lapack_make_complex_double( 7.63999999999999970e+000,
                                        -1.07899999999999990e+001 );
}
Esempio n. 19
0
static void init_b( lapack_int size, lapack_complex_double *b ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        b[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    b[0] = lapack_make_complex_double( 7.79000000000000000e+000,
                                       5.48000000000000040e+000 );
    b[8] = lapack_make_complex_double( -3.53900000000000010e+001,
                                       1.80100000000000020e+001 );
    b[1] = lapack_make_complex_double( -7.70000000000000020e-001,
                                       -1.60500000000000010e+001 );
    b[9] = lapack_make_complex_double( 4.23000000000000040e+000,
                                       -7.00199999999999960e+001 );
    b[2] = lapack_make_complex_double( -9.58000000000000010e+000,
                                       3.87999999999999990e+000 );
    b[10] = lapack_make_complex_double( -2.47899999999999990e+001,
                                        -8.40000000000000040e+000 );
    b[3] = lapack_make_complex_double( 2.98000000000000000e+000,
                                       -1.01800000000000000e+001 );
    b[11] = lapack_make_complex_double( 2.86800000000000000e+001,
                                        -3.98900000000000010e+001 );
}
Esempio n. 20
0
static void init_x( lapack_int size, lapack_complex_double *x ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        x[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    x[0] = lapack_make_complex_double( 1.00000000000000470e+000,
                                       -1.00000000000000890e+000 );
    x[8] = lapack_make_complex_double( -1.00000000000001090e+000,
                                       2.00000000000000490e+000 );
    x[1] = lapack_make_complex_double( -4.30138081129436570e-015,
                                       3.00000000000000220e+000 );
    x[9] = lapack_make_complex_double( 3.00000000000000440e+000,
                                       -3.99999999999999780e+000 );
    x[2] = lapack_make_complex_double( -4.00000000000000530e+000,
                                       -4.99999999999999640e+000 );
    x[10] = lapack_make_complex_double( -1.99999999999999180e+000,
                                        3.00000000000000040e+000 );
    x[3] = lapack_make_complex_double( 2.00000000000000580e+000,
                                       1.00000000000000110e+000 );
    x[11] = lapack_make_complex_double( 3.99999999999999380e+000,
                                        -5.00000000000000440e+000 );
}
Esempio n. 21
0
/* Auxiliary functions: zpbcon array parameters initialization */
static void init_ab( lapack_int size, lapack_complex_double *ab ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        ab[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    ab[0] = lapack_make_complex_double( 3.06431068920891250e+000,
                                        0.00000000000000000e+000 );
    ab[9] = lapack_make_complex_double( 1.11671395318950690e+000,
                                        0.00000000000000000e+000 );
    ab[18] = lapack_make_complex_double( 1.60663555873113610e+000,
                                         0.00000000000000000e+000 );
    ab[27] = lapack_make_complex_double( 4.28915067402645010e-001,
                                         0.00000000000000000e+000 );
    ab[1] = lapack_make_complex_double( 3.52444679909012350e-001,
                                        5.64564163187584510e-001 );
    ab[10] = lapack_make_complex_double( -3.58193787099676180e-002,
                                         -2.59690495647265210e-001 );
    ab[19] = lapack_make_complex_double( -2.05398167746655840e-001,
                                         -1.39421786591669420e+000 );
    ab[28] = lapack_make_complex_double( 0.00000000000000000e+000,
                                         0.00000000000000000e+000 );
}
Esempio n. 22
0
static void init_c( lapack_int size, lapack_complex_double *c ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        c[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    c[0] = lapack_make_complex_double( 7.29894574391705130e-001,
                                       0.00000000000000000e+000 );
    c[8] = lapack_make_complex_double( -2.59544973387760720e-001,
                                       0.00000000000000000e+000 );
    c[1] = lapack_make_complex_double( 6.25877780555793130e-001,
                                       0.00000000000000000e+000 );
    c[9] = lapack_make_complex_double( -4.32549625865536950e-002,
                                       0.00000000000000000e+000 );
    c[2] = lapack_make_complex_double( 2.51344947364408430e-001,
                                       0.00000000000000000e+000 );
    c[10] = lapack_make_complex_double( 4.95247410182067920e-001,
                                        0.00000000000000000e+000 );
    c[3] = lapack_make_complex_double( 1.11160386444491490e-001,
                                       0.00000000000000000e+000 );
    c[11] = lapack_make_complex_double( 8.27946506550234270e-001,
                                        0.00000000000000000e+000 );
}
Esempio n. 23
0
static void init_x( lapack_int size, lapack_complex_double *x ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        x[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    x[0] = lapack_make_complex_double( 1.00000000000000380e+000,
                                       -1.00000000000001200e+000 );
    x[8] = lapack_make_complex_double( -1.00000000000000490e+000,
                                       2.00000000000000930e+000 );
    x[1] = lapack_make_complex_double( -4.55440321195874030e-015,
                                       3.00000000000000220e+000 );
    x[9] = lapack_make_complex_double( 3.00000000000000440e+000,
                                       -3.99999999999999960e+000 );
    x[2] = lapack_make_complex_double( -4.00000000000000440e+000,
                                       -4.99999999999999470e+000 );
    x[10] = lapack_make_complex_double( -1.99999999999999530e+000,
                                        2.99999999999999600e+000 );
    x[3] = lapack_make_complex_double( 2.00000000000000710e+000,
                                       9.99999999999999780e-001 );
    x[11] = lapack_make_complex_double( 3.99999999999999290e+000,
                                        -4.99999999999999910e+000 );
}
Esempio n. 24
0
static void init_c( lapack_int size, lapack_complex_double *c ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        c[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    c[0] = lapack_make_complex_double( 8.62714450677153350e-001,
                                       -1.37285549322846670e-001 );
    c[8] = lapack_make_complex_double( 5.25619328131155870e-002,
                                       -4.22234210317574240e-001 );
    c[1] = lapack_make_complex_double( 2.34431506369553070e-001,
                                       -3.82827125669270130e-001 );
    c[9] = lapack_make_complex_double( 4.78167649382766290e-001,
                                       6.43408030515105340e-002 );
    c[2] = lapack_make_complex_double( 1.21716778596275620e-001,
                                       2.73482983966257860e-001 );
    c[10] = lapack_make_complex_double( -6.02546117975637290e-001,
                                        -3.97453882024362770e-001 );
    c[3] = lapack_make_complex_double( 8.23425425661291760e-002,
                                       7.68908382119097980e-002 );
    c[11] = lapack_make_complex_double( -9.83549568790308970e-002,
                                        -2.53893028222614610e-001 );
}
Esempio n. 25
0
static void init_work( lapack_int size, lapack_complex_double *work ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        work[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
}
Esempio n. 26
0
static void real_to_reciprocal_elements(lapack_complex_double *fc4_rec_elem,
					const double q[12],
					const double *fc4,
					const Darray *shortest_vectors,
					const Iarray *multiplicity,
					const int *p2s,
					const int *s2p,
					const int pi0,
					const int pi1,
					const int pi2,
					const int pi3)
{
  int i, j, k, l, m, num_satom;
  lapack_complex_double phase_factor, phase_factors[3];
  double fc4_rec_real[81], fc4_rec_imag[81];
  int fc4_elem_address;

  for (i = 0; i < 81; i++) {
    fc4_rec_real[i] = 0;
    fc4_rec_imag[i] = 0;
  }
  
  num_satom = multiplicity->dims[0];

  i = p2s[pi0];

  for (j = 0; j < num_satom; j++) {
    if (s2p[j] != p2s[pi1]) {
      continue;
    }
    phase_factors[0] =
      get_phase_factor(q, shortest_vectors, multiplicity, pi0, j, 1);

    for (k = 0; k < num_satom; k++) {
      if (s2p[k] != p2s[pi2]) {
	continue;
      }
      phase_factors[1] =
	get_phase_factor(q, shortest_vectors, multiplicity, pi0, k, 2);

      for (l = 0; l < num_satom; l++) {
	if (s2p[l] != p2s[pi3]) {
	  continue;
	}
	phase_factors[2] =
	  get_phase_factor(q, shortest_vectors, multiplicity, pi0, l, 3);
	
	fc4_elem_address = (i * 81 * num_satom * num_satom * num_satom +
			    j * 81 * num_satom * num_satom +
			    k * 81 * num_satom +
			    l * 81);

	phase_factor = phonoc_complex_prod(phase_factors[0], phase_factors[1]);
	phase_factor = phonoc_complex_prod(phase_factor, phase_factors[2]);
	for (m = 0; m < 81; m++) {
	  fc4_rec_real[m] +=
	    lapack_complex_double_real(phase_factor) * fc4[fc4_elem_address + m];
	  fc4_rec_imag[m] +=
	    lapack_complex_double_imag(phase_factor) * fc4[fc4_elem_address + m];
	}
      }
    }
  }

  for (i = 0; i < 81; i++) {
    fc4_rec_elem[i] =
      lapack_make_complex_double(fc4_rec_real[i], fc4_rec_imag[i]);
  }
}
Esempio n. 27
0
/* Auxiliary functions: zunmhr array parameters initialization */
static void init_a( lapack_int size, lapack_complex_double *a ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        a[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    a[0] = lapack_make_complex_double( -3.97000000000000020e+000,
                                       -5.04000000000000000e+000 );
    a[8] = lapack_make_complex_double( -1.13180518733977030e+000,
                                       -2.56930489882743900e+000 );
    a[16] = lapack_make_complex_double( -4.60274243753355350e+000,
                                        -1.42631904083292180e-001 );
    a[24] = lapack_make_complex_double( -1.42491228936652710e+000,
                                        1.73298370334218620e+000 );
    a[1] = lapack_make_complex_double( -5.47965327370263560e+000,
                                       0.00000000000000000e+000 );
    a[9] = lapack_make_complex_double( 1.85847282076558700e+000,
                                       -1.55018070644028950e+000 );
    a[17] = lapack_make_complex_double( 4.41446552691701300e+000,
                                        -7.63823711555098320e-001 );
    a[25] = lapack_make_complex_double( -4.80526133699015420e-001,
                                        -1.19759999733274710e+000 );
    a[2] = lapack_make_complex_double( 6.93222211814628180e-001,
                                       -4.82875276260254950e-001 );
    a[10] = lapack_make_complex_double( 6.26727681806422240e+000,
                                        0.00000000000000000e+000 );
    a[18] = lapack_make_complex_double( -4.50380940334500930e-001,
                                        -2.89818325981801020e-002 );
    a[26] = lapack_make_complex_double( -1.34668445007873290e+000,
                                        1.65792489538873020e+000 );
    a[3] = lapack_make_complex_double( -2.11294690792069330e-001,
                                       8.64412259893682090e-002 );
    a[11] = lapack_make_complex_double( 1.24214618876649560e-001,
                                        -2.28927604979682810e-001 );
    a[19] = lapack_make_complex_double( -3.49998583739325890e+000,
                                        0.00000000000000000e+000 );
    a[27] = lapack_make_complex_double( 2.56190811956891370e+000,
                                        -3.37083746096152880e+000 );
}
Esempio n. 28
0
static void init_q( lapack_int size, lapack_complex_double *q ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        q[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    q[0] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[1] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[3] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[1] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[3] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[3] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    q[3] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
}
Esempio n. 29
0
/* Auxiliary functions: ztrexc array parameters initialization */
static void init_t( lapack_int size, lapack_complex_double *t ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        t[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    t[0] = lapack_make_complex_double( -6.00000000000000000e+000,
                                       -7.00000000000000000e+000 );
    t[8] = lapack_make_complex_double( 3.59999999999999990e-001,
                                       -3.59999999999999990e-001 );
    t[16] = lapack_make_complex_double( -1.90000000000000000e-001,
                                        4.79999999999999980e-001 );
    t[24] = lapack_make_complex_double( 8.80000000000000000e-001,
                                        -2.50000000000000000e-001 );
    t[1] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    t[9] = lapack_make_complex_double( -5.00000000000000000e+000,
                                       2.00000000000000000e+000 );
    t[17] = lapack_make_complex_double( -2.99999999999999990e-002,
                                        -7.19999999999999970e-001 );
    t[25] = lapack_make_complex_double( -2.30000000000000010e-001,
                                        1.30000000000000000e-001 );
    t[2] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    t[10] = lapack_make_complex_double( 0.00000000000000000e+000,
                                        0.00000000000000000e+000 );
    t[18] = lapack_make_complex_double( 8.00000000000000000e+000,
                                        -1.00000000000000000e+000 );
    t[26] = lapack_make_complex_double( 9.39999999999999950e-001,
                                        5.30000000000000030e-001 );
    t[3] = lapack_make_complex_double( 0.00000000000000000e+000,
                                       0.00000000000000000e+000 );
    t[11] = lapack_make_complex_double( 0.00000000000000000e+000,
                                        0.00000000000000000e+000 );
    t[19] = lapack_make_complex_double( 0.00000000000000000e+000,
                                        0.00000000000000000e+000 );
    t[27] = lapack_make_complex_double( 3.00000000000000000e+000,
                                        -4.00000000000000000e+000 );
}
Esempio n. 30
0
/* Auxiliary functions: zhpcon array parameters initialization */
static void init_ap( lapack_int size, lapack_complex_double *ap ) {
    lapack_int i;
    for( i = 0; i < size; i++ ) {
        ap[i] = lapack_make_complex_double( 0.0, 0.0 );
    }
    ap[0] = lapack_make_complex_double( -1.36000000000000010e+000,
                                        0.00000000000000000e+000 );
    ap[1] = lapack_make_complex_double( 3.91000000000000010e+000,
                                        -1.50000000000000000e+000 );
    ap[2] = lapack_make_complex_double( 3.10028798127124030e-001,
                                        4.33302074396270180e-002 );
    ap[3] = lapack_make_complex_double( -1.51812020724010200e-001,
                                        3.74295842561370500e-001 );
    ap[4] = lapack_make_complex_double( -1.84000000000000010e+000,
                                        0.00000000000000000e+000 );
    ap[5] = lapack_make_complex_double( 5.63705048650877560e-001,
                                        2.85034950151971610e-001 );
    ap[6] = lapack_make_complex_double( 3.39658279960360960e-001,
                                        3.03145181135563540e-002 );
    ap[7] = lapack_make_complex_double( -5.41762438729157920e+000,
                                        0.00000000000000000e+000 );
    ap[8] = lapack_make_complex_double( 2.99724464607583510e-001,
                                        1.57826837278577770e-001 );
    ap[9] = lapack_make_complex_double( -7.10280989580184220e+000,
                                        0.00000000000000000e+000 );
}