static PyObject * makeEtaFrameRotMat(PyObject * self, PyObject * args)
{
PyArrayObject *bHat, *eHat, *rMat;
int db, de;
npy_intp nb, ne, dims[2];
double *bPtr, *ePtr, *rPtr;
/* Parse arguments */
if ( !PyArg_ParseTuple(args,"OO", &bHat,&eHat)) return(NULL);
if ( bHat == NULL || eHat == NULL ) return(NULL);
/* Verify shape of input arrays */
db = PyArray_NDIM(bHat);
de = PyArray_NDIM(eHat);
assert( db == 1 && de == 1);
/* Verify dimensions of input arrays */
nb = PyArray_DIMS(bHat)[0];
ne = PyArray_DIMS(eHat)[0];
assert( nb == 3 && ne == 3 );
/* Allocate the result matrix with appropriate dimensions and type */
dims[0] = 3; dims[1] = 3;
rMat = (PyArrayObject*)PyArray_EMPTY(2,dims,NPY_DOUBLE,0);
/* Grab pointers to the various data arrays */
bPtr = (double*)PyArray_DATA(bHat);
ePtr = (double*)PyArray_DATA(eHat);
rPtr = (double*)PyArray_DATA(rMat);
/* Call the actual function */
makeEtaFrameRotMat_cfunc(bPtr,ePtr,rPtr);
return((PyObject*)rMat);
}
void anglesToGvec_cfunc(long int nvecs, double * angs,
double * bHat_l, double * eHat_l,
double chi, double * rMat_c,
double * gVec_c)
{
/*
* takes an angle spec (2*theta, eta, omega) for nvecs g-vectors and
* returns the unit g-vector components in the crystal frame
*
* For unit g-vector in the lab frame, spec rMat_c = Identity and
* overwrite the omega values with zeros
*/
int i, j, k, l;
double rMat_e[9], rMat_s[9], rMat_ctst[9];
double gVec_e[3], gVec_l[3], gVec_c_tmp[3];
/* Need eta frame cob matrix (could omit for standard setting) */
makeEtaFrameRotMat_cfunc(bHat_l, eHat_l, rMat_e);
/* make vector array */
for (i=0; i<nvecs; i++) {
/* components in BEAM frame */
gVec_e[0] = cos(0.5*angs[3*i]) * cos(angs[3*i+1]);
gVec_e[1] = cos(0.5*angs[3*i]) * sin(angs[3*i+1]);
gVec_e[2] = sin(0.5*angs[3*i]);
/* take from beam frame to lab frame */
for (j=0; j<3; j++) {
gVec_l[j] = 0.0;
for (k=0; k<3; k++) {
gVec_l[j] += rMat_e[3*j+k]*gVec_e[k];
}
}
/* need pointwise rMat_s according to omega */
makeOscillRotMat_cfunc(chi, angs[3*i+2], rMat_s);
/* Compute dot(rMat_c.T, rMat_s.T) and hit against gVec_l */
for (j=0; j<3; j++) {
for (k=0; k<3; k++) {
rMat_ctst[3*j+k] = 0.0;
for (l=0; l<3; l++) {
rMat_ctst[3*j+k] += rMat_c[3*l+j]*rMat_s[3*k+l];
}
}
gVec_c_tmp[j] = 0.0;
for (k=0; k<3; k++) {
gVec_c_tmp[j] += rMat_ctst[3*j+k]*gVec_l[k];
}
gVec_c[3*i+j] = gVec_c_tmp[j];
}
}
}
void oscillAnglesOfHKLs_cfunc(long int npts, double * hkls, double chi,
double * rMat_c, double * bMat, double wavelength,
double * vInv_s, double * beamVec, double * etaVec,
double * oangs0, double * oangs1)
{
long int i;
int j, k;
bool crc = false;
double gVec_e[3], gHat_c[3], gHat_s[3], bHat_l[3], eHat_l[3], oVec[2];
double tVec0[3], tmpVec[3];
double rMat_e[9], rMat_s[9];
double a, b, c, sintht, cchi, schi;
double abMag, phaseAng, rhs, rhsAng;
double nrm0;
/* Normalize the beam vector */
nrm0 = 0.0;
for (j=0; j<3; j++) {
nrm0 += beamVec[j]*beamVec[j];
}
nrm0 = sqrt(nrm0);
if ( nrm0 > epsf ) {
for (j=0; j<3; j++)
bHat_l[j] = beamVec[j]/nrm0;
} else {
for (j=0; j<3; j++)
bHat_l[j] = beamVec[j];
}
/* Normalize the eta vector */
nrm0 = 0.0;
for (j=0; j<3; j++) {
nrm0 += etaVec[j]*etaVec[j];
}
nrm0 = sqrt(nrm0);
if ( nrm0 > epsf ) {
for (j=0; j<3; j++)
eHat_l[j] = etaVec[j]/nrm0;
} else {
for (j=0; j<3; j++)
eHat_l[j] = etaVec[j];
}
/* Check for consistent reference coordiantes */
nrm0 = 0.0;
for (j=0; j<3; j++) {
nrm0 += bHat_l[j]*eHat_l[j];
}
if ( fabs(nrm0) < 1.0-sqrt_epsf ) crc = true;
/* Compute the sine and cosine of the oscillation axis tilt */
cchi = cos(chi);
schi = sin(chi);
for (i=0; i<npts; i++) {
/* Compute gVec_c */
for (j=0; j<3; j++) {
gHat_c[j] = 0.0;
for (k=0; k<3; k++) {
gHat_c[j] += bMat[3*j+k]*hkls[3L*i+k];
}
}
/* Apply rMat_c to get gVec_s */
for (j=0; j<3; j++) {
gHat_s[j] = 0.0;
for (k=0; k<3; k++) {
gHat_s[j] += rMat_c[3*j+k]*gHat_c[k];
}
}
/* Apply vInv_s to gVec_s and store in tmpVec*/
tmpVec[0] = vInv_s[0]*gHat_s[0] + (vInv_s[5]*gHat_s[1] + vInv_s[4]*gHat_s[2])/sqrt(2.);
tmpVec[1] = vInv_s[1]*gHat_s[1] + (vInv_s[5]*gHat_s[0] + vInv_s[3]*gHat_s[2])/sqrt(2.);
tmpVec[2] = vInv_s[2]*gHat_s[2] + (vInv_s[4]*gHat_s[0] + vInv_s[3]*gHat_s[1])/sqrt(2.);
/* Apply rMat_c.T to get stretched gVec_c and store norm in nrm0*/
nrm0 = 0.0;
for (j=0; j<3; j++) {
gHat_c[j] = 0.0;
for (k=0; k<3; k++) {
gHat_c[j] += rMat_c[j+3*k]*tmpVec[k];
}
nrm0 += gHat_c[j]*gHat_c[j];
}
nrm0 = sqrt(nrm0);
/* Normalize both gHat_c and gHat_s */
if ( nrm0 > epsf ) {
for (j=0; j<3; j++) {
gHat_c[j] /= nrm0;
gHat_s[j] = tmpVec[j]/nrm0;
}
}
/* Compute the sine of the Bragg angle */
sintht = 0.5*wavelength*nrm0;
/* Compute the coefficients of the harmonic equation */
a = gHat_s[2]*bHat_l[0] + schi*gHat_s[0]*bHat_l[1] - cchi*gHat_s[0]*bHat_l[2];
b = gHat_s[0]*bHat_l[0] - schi*gHat_s[2]*bHat_l[1] + cchi*gHat_s[2]*bHat_l[2];
c = - sintht - cchi*gHat_s[1]*bHat_l[1] - schi*gHat_s[1]*bHat_l[2];
/* Form solution */
abMag = sqrt(a*a + b*b); assert( abMag > 0.0 );
phaseAng = atan2(b,a);
rhs = c/abMag;
if ( fabs(rhs) > 1.0 ) {
for (j=0; j<3; j++)
oangs0[3L*i+j] = NAN;
for (j=0; j<3; j++)
oangs1[3L*i+j] = NAN;
continue;
}
rhsAng = asin(rhs);
/* Write ome angles */
oangs0[3L*i+2] = rhsAng - phaseAng;
oangs1[3L*i+2] = M_PI - rhsAng - phaseAng;
if ( crc ) {
makeEtaFrameRotMat_cfunc(bHat_l,eHat_l,rMat_e);
oVec[0] = chi;
oVec[1] = oangs0[3L*i+2];
makeOscillRotMat_cfunc(oVec[0], oVec[1], rMat_s);
for (j=0; j<3; j++) {
tVec0[j] = 0.0;
for (k=0; k<3; k++) {
tVec0[j] += rMat_s[3*j+k]*gHat_s[k];
}
}
for (j=0; j<2; j++) {
gVec_e[j] = 0.0;
for (k=0; k<3; k++) {
gVec_e[j] += rMat_e[3*k+j]*tVec0[k];
}
}
oangs0[3L*i+1] = atan2(gVec_e[1],gVec_e[0]);
oVec[1] = oangs1[3L*i+2];
makeOscillRotMat_cfunc(oVec[0], oVec[1], rMat_s);
for (j=0; j<3; j++) {
tVec0[j] = 0.0;
for (k=0; k<3; k++) {
tVec0[j] += rMat_s[3*j+k]*gHat_s[k];
}
}
for (j=0; j<2; j++) {
gVec_e[j] = 0.0;
for (k=0; k<3; k++) {
gVec_e[j] += rMat_e[3*k+j]*tVec0[k];
}
}
oangs1[3L*i+1] = atan2(gVec_e[1],gVec_e[0]);
oangs0[3L*i+0] = 2.0*asin(sintht);
oangs1[3L*i+0] = oangs0[3L*i+0];
}
}
}
void detectorXYToGvec_cfunc(long int npts, double * xy,
double * rMat_d, double * rMat_s,
double * tVec_d, double * tVec_s, double * tVec_c,
double * beamVec, double * etaVec,
double * tTh, double * eta, double * gVec_l)
{
long int i;
int j, k;
double nrm, phi, bVec[3], tVec1[3], tVec2[3], dHat_l[3], n_g[3];
double rMat_e[9];
/* Fill rMat_e */
makeEtaFrameRotMat_cfunc(beamVec,etaVec,rMat_e);
/* Normalize the beam vector */
nrm = 0.0;
for (j=0; j<3; j++) {
nrm += beamVec[j]*beamVec[j];
}
nrm = sqrt(nrm);
if ( nrm > epsf ) {
for (j=0; j<3; j++)
bVec[j] = beamVec[j]/nrm;
} else {
for (j=0; j<3; j++)
bVec[j] = beamVec[j];
}
/* Compute shift vector */
for (j=0; j<3; j++) {
tVec1[j] = tVec_d[j]-tVec_s[j];
for (k=0; k<3; k++) {
tVec1[j] -= rMat_s[3*j+k]*tVec_c[k];
}
}
for (i=0; i<npts; i++) {
/* Compute dHat_l vector */
nrm = 0.0;
for (j=0; j<3; j++) {
dHat_l[j] = tVec1[j];
for (k=0; k<2; k++) {
dHat_l[j] += rMat_d[3*j+k]*xy[2*i+k];
}
nrm += dHat_l[j]*dHat_l[j];
}
if ( nrm > epsf ) {
for (j=0; j<3; j++) {
dHat_l[j] /= sqrt(nrm);
}
}
/* Compute tTh */
nrm = 0.0;
for (j=0; j<3; j++) {
nrm += bVec[j]*dHat_l[j];
}
tTh[i] = acos(nrm);
/* Compute eta */
for (j=0; j<2; j++) {
tVec2[j] = 0.0;
for (k=0; k<3; k++) {
tVec2[j] += rMat_e[3*k+j]*dHat_l[k];
}
}
eta[i] = atan2(tVec2[1],tVec2[0]);
/* Compute n_g vector */
nrm = 0.0;
for (j=0; j<3; j++) {
n_g[j] = bVec[(j+1)%3]*dHat_l[(j+2)%3]-bVec[(j+2)%3]*dHat_l[(j+1)%3];
nrm += n_g[j]*n_g[j];
}
nrm = sqrt(nrm);
for (j=0; j<3; j++) {
n_g[j] /= nrm;
}
/* Rotate dHat_l vector */
// rotateVectorAboutAxis_cfunc(tTh[i], n_g, dHat_l, &gVec_l[3*i]);
phi = 0.5*(M_PI-tTh[i]);
rotate_vecs_about_axis_cfunc(1, &phi, 1, n_g, 1, dHat_l, &gVec_l[3*i]);
}
}
