Example #1
0
int main() {
  int array[5];
  int array_length;
  array_length = sizeof(array) / sizeof(int);
  scanArray(array, array_length);
  invertArray(array, array_length);
  sortArray(array, array_length);
  printf("\n");
  return(0);
}
Example #2
0
/* calc HKL from angles (in degrees) */
int angles_to_HKL(double angles_arg[4], double omtx_inv[3][3], double a0_inv[3][3],
		double hkl[3]) {
	double vec[3];
	double r1[3][3], r2[3][3], r3[3][3], rot[3][3], rot_i[3][3];
	double tmp[3][3];
	double angles[4];
	int i;

	for (i=0; i<4; i++) angles[i] = angles_arg[i]*D2R;

	vec[0] = sin(angles[TTH_INDEX]/2); vec[1] = 0; vec[2] = 0;

	calc_rotZ(angles[TH_INDEX]-angles[TTH_INDEX]/2, r1);
	if (orientDebug) printArray(r1, "angles_to_HKL:rotZ");
	calc_rotY(angles[CHI_INDEX], r2);
	if (orientDebug) printArray(r2, "angles_to_HKL:rotY");
	calc_rotZ(angles[PHI_INDEX], r3);
	if (orientDebug) printArray(r3, "angles_to_HKL:rotZ");
	multArrayArray(r1, r2, rot);
	multArrayArray(rot, r3, rot);
	if (orientDebug) printArray(rot, "angles_to_HKL:rot");

	if (invertArray(rot, rot_i)) {
		if (orientDebug) {
			printf("angles_to_HKL: can't invert rotation matrix\n");
			printArray(rot, "rot");
		}
		hkl[0] = hkl[1] = hkl[2] = 0;
		return(-1);
	}
	multArrayArray(a0_inv, omtx_inv, tmp);
	if (orientDebug) printArray(tmp, "angles_to_HKL:a0_i X o_i");
	multArrayArray(tmp, rot_i, tmp);
	if (orientDebug) printArray(tmp, "angles_to_HKL:a0_i X o_i X rot_i");
	multArrayVector(tmp, vec, hkl);
	return(0);
}
Example #3
0
/* Calculate orientation matrix */
int calc_OMTX(double v1_hkl[3], double v1_angles[4], double v2_hkl[3], double v2_angles[4],
                double a0[3][3], double a0_i[3][3], double o[3][3], double o_i[3][3]) {
	double v1p[3], v2p[3], v3p[3];
	double v1pp[3], v2pp[3], v3pp[3];
	double tmp[3];
	double Vp[3][3], Vpp[3][3], Vpp_i[3][3];
	double I[3][3] = {{1,0,0},{0,1,0},{0,0,1}};
	int i, j;

	if (orientDebug) {
		printVector(v1_hkl, "calc_OMTX: v1_hkl");
		print4Vector(v1_angles, "calc_OMTX: v1_angles");
		printVector(v2_hkl, "calc_OMTX: v2_hkl");
		print4Vector(v2_angles, "calc_OMTX: v2_angles");
		printArray(a0, "calc_OMTX: a0\n");
	}

	/** calc Vp[3][3] **/
	multArrayVector(a0, v1_hkl, v1p);
	if (orientDebug) printVector(v1p, "calc_OMTX: v1p");
	multArrayVector(a0, v2_hkl, tmp);
	cross(v1p, tmp, v2p);
	if (orientDebug) printVector(v2p, "calc_OMTX: v2p");
	cross(v2p, v1p, v3p);
	if (orientDebug) printVector(v3p, "calc_OMTX: v3p");
	/* Vp array columns are v<i>p */
	for (i=0; i<3; i++) {
		Vp[0][i] = v1p[i];
		Vp[1][i] = v2p[i];
		Vp[2][i] = v3p[i];
	}
	if (orientDebug) printArray(Vp, "calc_OMTX: Vp\n");

	/** calc Vpp[3][3] **/
	angles_to_HKL(v1_angles, I, a0_i, v1pp);
	multArrayVector(a0, v1pp, v1pp);
	if (orientDebug) printVector(v1pp, "calc_OMTX: v1pp");

	angles_to_HKL(v2_angles, I, a0_i, v2pp);
	multArrayVector(a0, v2pp, v2pp);
	if (orientDebug) printVector(v2pp, "calc_OMTX: A0 X HKL(v2)");
	cross(v1pp, v2pp, v2pp);
	if (orientDebug) printVector(v2pp, "calc_OMTX: v2pp");

	cross(v2pp, v1pp, v3pp);

	/* Vpp array columns are v<i>pp */
	for (i=0; i<3; i++) {
		Vpp[0][i] = v1pp[i];
		Vpp[1][i] = v2pp[i];
		Vpp[2][i] = v3pp[i];
	}
	if (orientDebug) printArray(Vp, "calc_OMTX: Vp");

	if (invertArray(Vpp, Vpp_i)) {
		if (orientDebug) {
			printf("calc_OMTX: can't invert Vpp matrix\n");
			printArray(Vpp, "Vpp");
		}
		goto error;
	}
	/** o = Vpp_i Vpp **/
	multArrayArray(Vpp_i, Vp, o);
	if (orientDebug) printArray(o, "calc_OMTX: OMTX");
	if (invertArray(o, o_i)) {
		if (orientDebug) {
			printf("angles_to_HKL: can't invert OMTX\n");
			printArray(o, "o");
		}
		goto error;
	}
	return(0);
	
error:
	for (i=0; i<3; i++) {
		for (j=0; j<3; j++) {
			o[i][j] = o_i[i][j] = (i==j ? 1 : 0);
		}
	}
	return(-1);
}
Example #4
0
/*
 * Calc A0 matrix from lattice parameters and wavelength, and return it as r[][].
 * Lattice spacings a,b,c and wavelength lambda are in same (arbitrary) units.
 * Lattice angles alpha, beta, gamma are in units of degrees.
 */
int calc_A0(double a, double b, double c,
              double alpha_arg, double beta_arg, double gamma_arg,
			  double lambda, double r[3][3], double r_i[3][3]) {
	double A[3], B[3], C[3];
	double AxB[3], BxC[3], CxA[3];
	double tmp;
	double alpha = alpha_arg * D2R;
	double beta = beta_arg * D2R;
	double gamma = gamma_arg * D2R;

	if (orientDebug) printf("calc_A0: a=%f,b=%f,c=%f,alpha=%f,beta=%f,gamma=%f,lambda=%f\n",
			a,b,c,alpha,beta,gamma,lambda);
	A[0] = a;
	A[1] = 0;
	A[2] = 0;
	if (orientDebug) printVector(A, "calc_A0:A");

	B[0] = b * cos(gamma);
	B[1] = b * sin(gamma);
	B[2] = 0;
	if (orientDebug) printVector(B, "calc_A0:B");

	tmp = (cos(alpha) - cos(beta)*cos(gamma))/sin(gamma);
	C[0] = c * cos(beta);
	C[1] = c * tmp;
	C[2] = c * sqrt(1 - cos(beta)*cos(beta) - tmp*tmp);
	if (orientDebug) printVector(C, "calc_A0:C");

	/* r = factor * |BxC, CxA, AxB| */
	tmp = lambda/(2 * dotcross(A,B,C));
	if (orientDebug) printf("calc_A0: lambda/(2*AXB.C) = %f\n", tmp);
	cross(A, B, AxB);
	cross(B, C, BxC);
	cross(C, A, CxA);
	if (orientDebug) {
		printVector(AxB, "calc_A0:AxB");
		printVector(BxC, "calc_A0:BxC");
		printVector(CxA, "calc_A0:CxA");
	}
	r[0][0] = tmp * BxC[0];
	r[0][1] = tmp * CxA[0];
	r[0][2] = tmp * AxB[0];
	r[1][0] = tmp * BxC[1];
	r[1][1] = tmp * CxA[1];
	r[1][2] = tmp * AxB[1];
	r[2][0] = tmp * BxC[2];
	r[2][1] = tmp * CxA[2];
	r[2][2] = tmp * AxB[2];
	if (invertArray(r, r_i)) {
		int i, j;
		/* error */
		if (orientDebug) {
			printf("calc_A0: can't invert A0 matrix\n");
			printArray(r, "A0");
		}
		for (i=0; i<3; i++) {
			for (j=0; j<3; j++) {
				r[i][j] = r_i[i][j] = (i==j ? 1 : 0);
			}
		}
		return(-1);
	}
	return(0);
}