- Initial commit of a UB calculation setup for four circle

diffractometers
2005-03-23 08:19:47 +00:00
parent 2b63ad06b2
commit beba0d4644
18 changed files with 1236 additions and 55 deletions
--- a/cell.c
+++ b/cell.c
@ -0,0 +1,150 @@
+/**
+ * this is a little library for performing crystallographic cell transformations
+ * for SICS. Some of the actual code was lifted from the Risoe program tascom.
+ *
+ * copyright: see file COPYRIGHT
+ *
+ * Mark Koennecke, March 2005
+ */
+#include <stdio.h>
+#include <assert.h>
+#include <math.h>
+#include "trigd.h"
+#include "cell.h"
+
+/* define constants */
+#ifndef PI
+#define PI              (3.1415926536)  /* pi */
+#endif
+#define TWOPI           (2*PI)          /* 2*pi */
+
+/*******************************************************************************
+* Transform direct lattice to reciprocal lattice.
+*******************************************************************************/
+int directToReciprocalLattice(lattice direct, plattice reciprocal)
+{
+  double alfa, beta, gamma;
+  double cos_alfa, cos_beta, cos_gamma;
+  double sin_alfa, sin_beta, sin_gamma;
+  double ad, bd, cd;
+  double arg, vol;
+
+  alfa = direct.alpha;
+  beta = direct.beta;
+  gamma = direct.gamma;
+
+  cos_alfa = Cosd (alfa);
+  cos_beta = Cosd (beta);
+  cos_gamma = Cosd (gamma);
+
+  sin_alfa = Sind (alfa);
+  sin_beta = Sind (beta);
+  sin_gamma = Sind (gamma);
+
+  reciprocal->alpha = Acosd ((cos_beta*cos_gamma - cos_alfa)/sin_beta/sin_gamma);
+  reciprocal->beta =Acosd ((cos_alfa*cos_gamma - cos_beta)/sin_alfa/sin_gamma);
+  reciprocal->gamma = Acosd ((cos_alfa*cos_beta - cos_gamma)/sin_alfa/sin_beta);
+
+  ad = direct.a;
+  bd = direct.b;
+  cd = direct.c;
+
+  arg = 1 + 2*cos_alfa*cos_beta*cos_gamma - cos_alfa*cos_alfa -
+					    cos_beta*cos_beta -
+					    cos_gamma*cos_gamma;
+  if (arg < 0.0)
+    {
+      return REC_NO_VOLUME;
+    }
+
+  vol = ad*bd*cd*sqrt (arg);
+  reciprocal->a = bd*cd*sin_alfa/vol;
+  reciprocal->b = ad*cd*sin_beta/vol;
+  reciprocal->c = bd*ad*sin_gamma/vol;
+
+  return (0);
+}
+/*******************************************************************************
+* Transform reciprocal lattice to direct lattice.
+*******************************************************************************/
+int reciprocalToDirectLattice(lattice reciprocal, plattice direct)
+{
+  double alfa, beta, gamma;
+  double cos_alfa, cos_beta, cos_gamma;
+  double sin_alfa, sin_beta, sin_gamma;
+  double ar, br, cr;
+  double arg, vol;
+
+  alfa = reciprocal.alpha;
+  beta = reciprocal.beta;
+  gamma = reciprocal.gamma;
+
+  cos_alfa = Cosd (alfa);
+  cos_beta = Cosd (beta);
+  cos_gamma = Cosd (gamma);
+
+  sin_alfa = Sind (alfa);
+  sin_beta = Sind (beta);
+  sin_gamma = Sind (gamma);
+
+  direct->alpha = Acosd ((cos_beta*cos_gamma - cos_alfa)/sin_beta/sin_gamma);
+  direct->beta = Acosd ((cos_alfa*cos_gamma - cos_beta)/sin_alfa/sin_gamma);
+  direct->gamma =  Acosd ((cos_alfa*cos_beta - cos_gamma)/sin_alfa/sin_beta);
+
+  ar = reciprocal.a;
+  br = reciprocal.b;
+  cr = reciprocal.c;
+
+  arg = 1 + 2*cos_alfa*cos_beta*cos_gamma - cos_alfa*cos_alfa -
+					    cos_beta*cos_beta -
+					    cos_gamma*cos_gamma;
+  if (arg < 0.0)
+    {
+      return REC_NO_VOLUME;
+    }
+
+  vol = ar*br*cr*sqrt (arg);
+  direct->a = br*cr*sin_alfa/vol;
+  direct->b = ar*cr*sin_beta/vol;
+  direct->c = br*ar*sin_gamma/vol;
+
+  return (0);
+}
+/***************************************************************************************
+ * Build a B matrix
+ ***************************************************************************************/
+int calculateBMatrix(lattice direct, MATRIX B) {
+  lattice reciprocal;
+  int status;
+
+  assert(MatRow(B) == 3);
+  assert(MatCol(B) == 3);
+
+  status = directToReciprocalLattice(direct,&reciprocal);
+  if(status < 0) {
+    return status;
+  }
+  
+  mat_fill(B,ZERO_MATRIX);
+  
+  /*
+    top row
+  */
+  B[0][0] = reciprocal.a;
+  B[0][1] = reciprocal.b*Cosd(reciprocal.gamma);
+  B[0][2] = reciprocal.c*Cosd(reciprocal.beta);
+
+  /*
+    middle row
+  */
+  B[1][1] = reciprocal.b*Sind(reciprocal.gamma);
+  B[1][2] = -reciprocal.c*Sind(reciprocal.beta)*Cosd(direct.alpha);
+  
+  /*
+    bottom row
+  */
+  B[2][2] = 1./direct.c;
+  
+  return 1;
+}
+