sics/cell.c

/**
 * 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 */
/*****************************************************************************
 * default value for a cell
 ****************************************************************************/
void defaultCell(plattice cell)
{
  cell->a = 1.;
  cell->b = 1.;
  cell->c = 1.;
  cell->alpha = 90.;
  cell->beta = 90.;
  cell->gamma = 90.;
}

/*******************************************************************************
* 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;
}

/*--------------------------------------------------------------------------*/
int cellFromUB(MATRIX UB, plattice direct)
{
  MATRIX UBTRANS, GINV, G;

  UBTRANS = mat_tran(UB);
  if (UBTRANS == NULL) {
    return CELLNOMEMORY;
  }
  GINV = mat_mul(UBTRANS, UB);
  if (GINV == NULL) {
    mat_free(UBTRANS);
    return CELLNOMEMORY;
  }
  G = mat_inv(GINV);
  if (G == NULL) {
    mat_free(UBTRANS);
    mat_free(GINV);
    return CELLNOMEMORY;
  }
  direct->a = sqrt(G[0][0]);
  direct->b = sqrt(G[1][1]);
  direct->c = sqrt(G[2][2]);
  direct->alpha = Acosd(G[1][2] / (direct->b * direct->c));
  direct->beta = Acosd(G[2][0] / (direct->a * direct->c));
  direct->gamma = Acosd(G[0][1] / (direct->a * direct->c));
  return 1;
}