- Adapted indenation to new agreed upon system
- Added support for second generation scriptcontext based counter
This commit is contained in:
koennecke
612
ubcalc.c
612
ubcalc.c
@ -25,42 +25,47 @@
|
||||
#include "reflist.h"
|
||||
#include "singlediff.h"
|
||||
/*----------------------------------------------------------------------*/
|
||||
static void killUBCALC(void *pData){
|
||||
pUBCALC self = (pUBCALC)pData;
|
||||
if(self == NULL){
|
||||
static void killUBCALC(void *pData)
|
||||
{
|
||||
pUBCALC self = (pUBCALC) pData;
|
||||
if (self == NULL) {
|
||||
return;
|
||||
}
|
||||
if(self->pDes != NULL){
|
||||
if (self->pDes != NULL) {
|
||||
DeleteDescriptor(self->pDes);
|
||||
}
|
||||
if(self->UB != NULL){
|
||||
if (self->UB != NULL) {
|
||||
mat_free(self->UB);
|
||||
}
|
||||
free(self);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*/
|
||||
static int SaveUBCalc(void *data, char *name, FILE *fd){
|
||||
pUBCALC self = (pUBCALC)data;
|
||||
if(self == NULL){
|
||||
static int SaveUBCalc(void *data, char *name, FILE * fd)
|
||||
{
|
||||
pUBCALC self = (pUBCALC) data;
|
||||
if (self == NULL) {
|
||||
return 0;
|
||||
}
|
||||
fprintf(fd,"%s difftheta %f\n", name, self->allowedDeviation);
|
||||
fprintf(fd, "%s difftheta %f\n", name, self->allowedDeviation);
|
||||
fprintf(fd, "%s maxindex %d\n", name, self->indexSearchLimit);
|
||||
fprintf(fd ,"%s maxlist %d\n", name, self->maxSuggestions);
|
||||
fprintf(fd, "%s maxlist %d\n", name, self->maxSuggestions);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static pUBCALC makeUBCALC(pHKL hkl){
|
||||
static pUBCALC makeUBCALC(pHKL hkl)
|
||||
{
|
||||
pUBCALC pNew = NULL;
|
||||
|
||||
pNew = (pUBCALC)malloc(sizeof(UBCALC));
|
||||
if(pNew == NULL){
|
||||
pNew = (pUBCALC) malloc(sizeof(UBCALC));
|
||||
if (pNew == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
memset(pNew,0,sizeof(UBCALC));
|
||||
memset(pNew, 0, sizeof(UBCALC));
|
||||
pNew->pDes = CreateDescriptor("UBcalc");
|
||||
pNew->UB = mat_creat(3,3,UNIT_MATRIX);
|
||||
if(pNew->pDes == NULL || pNew->UB == NULL){
|
||||
pNew->UB = mat_creat(3, 3, UNIT_MATRIX);
|
||||
if (pNew->pDes == NULL || pNew->UB == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
pNew->pDes->SaveStatus = SaveUBCalc;
|
||||
@ -70,161 +75,176 @@ static pUBCALC makeUBCALC(pHKL hkl){
|
||||
pNew->maxSuggestions = 10;
|
||||
return pNew;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------*/
|
||||
int CreateUBCalc(SConnection *pCon, SicsInterp *pSics, char *name,
|
||||
char *hklname){
|
||||
pUBCALC pNew = NULL;
|
||||
int status;
|
||||
pHKL hkl = NULL;
|
||||
int CreateUBCalc(SConnection * pCon, SicsInterp * pSics, char *name,
|
||||
char *hklname)
|
||||
{
|
||||
pUBCALC pNew = NULL;
|
||||
int status;
|
||||
pHKL hkl = NULL;
|
||||
|
||||
|
||||
hkl = FindCommandData(pSics,hklname,"4-Circle-Calculus");
|
||||
if(hkl == NULL){
|
||||
SCWrite(pCon,"ERROR: HKL object not found or wrong type",eError);
|
||||
return 0;
|
||||
}
|
||||
hkl = FindCommandData(pSics, hklname, "4-Circle-Calculus");
|
||||
if (hkl == NULL) {
|
||||
SCWrite(pCon, "ERROR: HKL object not found or wrong type", eError);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pNew = makeUBCALC(hkl);
|
||||
if(pNew == NULL){
|
||||
SCWrite(pCon,"ERROR: out of memory creating UBCALC",eError);
|
||||
return 0;
|
||||
}
|
||||
status = AddCommand(pSics,name,UBCalcWrapper,killUBCALC,pNew);
|
||||
if(status != 1){
|
||||
SCWrite(pCon,"ERROR: failed to create duplicate UBCALC module",eError);
|
||||
}
|
||||
return status;
|
||||
pNew = makeUBCALC(hkl);
|
||||
if (pNew == NULL) {
|
||||
SCWrite(pCon, "ERROR: out of memory creating UBCALC", eError);
|
||||
return 0;
|
||||
}
|
||||
status = AddCommand(pSics, name, UBCalcWrapper, killUBCALC, pNew);
|
||||
if (status != 1) {
|
||||
SCWrite(pCon, "ERROR: failed to create duplicate UBCALC module",
|
||||
eError);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------*/
|
||||
int MakeUBCalc(SConnection *pCon, SicsInterp *pSics, void *pData,
|
||||
int argc, char *argv[]){
|
||||
int MakeUBCalc(SConnection * pCon, SicsInterp * pSics, void *pData,
|
||||
int argc, char *argv[])
|
||||
{
|
||||
|
||||
if(argc < 3){
|
||||
SCWrite(pCon,"ERROR: missing argument to MakeUBCalc: MakeUBCalc name hklobject",eError);
|
||||
return 0;
|
||||
}
|
||||
return CreateUBCalc(pCon,pSics,argv[1], argv[2]);
|
||||
if (argc < 3) {
|
||||
SCWrite(pCon,
|
||||
"ERROR: missing argument to MakeUBCalc: MakeUBCalc name hklobject",
|
||||
eError);
|
||||
return 0;
|
||||
}
|
||||
return CreateUBCalc(pCon, pSics, argv[1], argv[2]);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static void listUB(SConnection *pCon, MATRIX UB){
|
||||
static void listUB(SConnection * pCon, MATRIX UB)
|
||||
{
|
||||
Tcl_DString list;
|
||||
char pBueffel[255];
|
||||
int i;
|
||||
|
||||
|
||||
Tcl_DStringInit(&list);
|
||||
if(UB == NULL){
|
||||
Tcl_DStringAppend(&list,"NO UB",-1);
|
||||
if (UB == NULL) {
|
||||
Tcl_DStringAppend(&list, "NO UB", -1);
|
||||
} else {
|
||||
Tcl_DStringAppend(&list,"UB = ", -1);
|
||||
for(i = 0; i < 3; i++){
|
||||
snprintf(pBueffel,255,"%f %f %f\n", UB[i][0],
|
||||
UB[i][1],UB[i][2]);
|
||||
Tcl_DStringAppend(&list,pBueffel,-1);
|
||||
Tcl_DStringAppend(&list, "UB = ", -1);
|
||||
for (i = 0; i < 3; i++) {
|
||||
snprintf(pBueffel, 255, "%f %f %f\n", UB[i][0], UB[i][1], UB[i][2]);
|
||||
Tcl_DStringAppend(&list, pBueffel, -1);
|
||||
}
|
||||
}
|
||||
SCWrite(pCon,Tcl_DStringValue(&list),eValue);
|
||||
SCWrite(pCon, Tcl_DStringValue(&list), eValue);
|
||||
Tcl_DStringFree(&list);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int updateUBCALC(pUBCALC self, SConnection *pCon,
|
||||
char *id1, char *id2, char *id3){
|
||||
const double *cell;
|
||||
double hkl[3], angles[4];
|
||||
pSICSOBJ refList;
|
||||
|
||||
cell = SXGetCell();
|
||||
self->direct.a = cell[0];
|
||||
self->direct.b = cell[1];
|
||||
self->direct.c = cell[2];
|
||||
self->direct.alpha = cell[3];
|
||||
self->direct.beta = cell[4];
|
||||
self->direct.gamma = cell[5];
|
||||
static int updateUBCALC(pUBCALC self, SConnection * pCon,
|
||||
char *id1, char *id2, char *id3)
|
||||
{
|
||||
const double *cell;
|
||||
double hkl[3], angles[4];
|
||||
pSICSOBJ refList;
|
||||
|
||||
refList = SXGetReflectionList();
|
||||
if(id1 != NULL){
|
||||
if(!GetRefIndexID(refList,id1,hkl)){
|
||||
SCPrintf(pCon,eError,"ERROR: reflection with id %s not found",id1);
|
||||
return 0;
|
||||
} else {
|
||||
self->r1.h = hkl[0];
|
||||
self->r1.k = hkl[1];
|
||||
self->r1.l = hkl[2];
|
||||
GetRefAnglesID(refList,id1,angles);
|
||||
self->r1.s2t = angles[0];
|
||||
self->r1.om = angles[1];
|
||||
self->r1.chi = angles[2];
|
||||
self->r1.phi = angles[3];
|
||||
}
|
||||
}
|
||||
cell = SXGetCell();
|
||||
self->direct.a = cell[0];
|
||||
self->direct.b = cell[1];
|
||||
self->direct.c = cell[2];
|
||||
self->direct.alpha = cell[3];
|
||||
self->direct.beta = cell[4];
|
||||
self->direct.gamma = cell[5];
|
||||
|
||||
if(id2 != NULL){
|
||||
if(!GetRefIndexID(refList,id2,hkl)){
|
||||
SCPrintf(pCon,eError,"ERROR: reflection with id %s not found",id2);
|
||||
return 0;
|
||||
} else {
|
||||
self->r2.h = hkl[0];
|
||||
self->r2.k = hkl[1];
|
||||
self->r2.l = hkl[2];
|
||||
GetRefAnglesID(refList,id2,angles);
|
||||
self->r2.s2t = angles[0];
|
||||
self->r2.om = angles[1];
|
||||
self->r2.chi = angles[2];
|
||||
self->r2.phi = angles[3];
|
||||
}
|
||||
}
|
||||
if(id3 != NULL){
|
||||
if(!GetRefIndexID(refList,id3,hkl)){
|
||||
SCPrintf(pCon,eError,"ERROR: reflection with id %s not found",id3);
|
||||
return 0;
|
||||
} else {
|
||||
self->r3.h = hkl[0];
|
||||
self->r3.k = hkl[1];
|
||||
self->r3.l = hkl[2];
|
||||
GetRefAnglesID(refList,id3,angles);
|
||||
self->r3.s2t = angles[0];
|
||||
self->r3.om = angles[1];
|
||||
self->r3.chi = angles[2];
|
||||
self->r3.phi = angles[3];
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
refList = SXGetReflectionList();
|
||||
if (id1 != NULL) {
|
||||
if (!GetRefIndexID(refList, id1, hkl)) {
|
||||
SCPrintf(pCon, eError, "ERROR: reflection with id %s not found",
|
||||
id1);
|
||||
return 0;
|
||||
} else {
|
||||
self->r1.h = hkl[0];
|
||||
self->r1.k = hkl[1];
|
||||
self->r1.l = hkl[2];
|
||||
GetRefAnglesID(refList, id1, angles);
|
||||
self->r1.s2t = angles[0];
|
||||
self->r1.om = angles[1];
|
||||
self->r1.chi = angles[2];
|
||||
self->r1.phi = angles[3];
|
||||
}
|
||||
}
|
||||
|
||||
if (id2 != NULL) {
|
||||
if (!GetRefIndexID(refList, id2, hkl)) {
|
||||
SCPrintf(pCon, eError, "ERROR: reflection with id %s not found",
|
||||
id2);
|
||||
return 0;
|
||||
} else {
|
||||
self->r2.h = hkl[0];
|
||||
self->r2.k = hkl[1];
|
||||
self->r2.l = hkl[2];
|
||||
GetRefAnglesID(refList, id2, angles);
|
||||
self->r2.s2t = angles[0];
|
||||
self->r2.om = angles[1];
|
||||
self->r2.chi = angles[2];
|
||||
self->r2.phi = angles[3];
|
||||
}
|
||||
}
|
||||
if (id3 != NULL) {
|
||||
if (!GetRefIndexID(refList, id3, hkl)) {
|
||||
SCPrintf(pCon, eError, "ERROR: reflection with id %s not found",
|
||||
id3);
|
||||
return 0;
|
||||
} else {
|
||||
self->r3.h = hkl[0];
|
||||
self->r3.k = hkl[1];
|
||||
self->r3.l = hkl[2];
|
||||
GetRefAnglesID(refList, id3, angles);
|
||||
self->r3.s2t = angles[0];
|
||||
self->r3.om = angles[1];
|
||||
self->r3.chi = angles[2];
|
||||
self->r3.phi = angles[3];
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int calcUB(pUBCALC self, SConnection *pCon,
|
||||
char *ref1, char *ref2){
|
||||
static int calcUB(pUBCALC self, SConnection * pCon, char *ref1, char *ref2)
|
||||
{
|
||||
MATRIX newUB = NULL;
|
||||
int err = 1;
|
||||
pSingleDiff single = NULL;
|
||||
|
||||
if(!updateUBCALC(self,pCon,ref1,ref2,NULL)){
|
||||
return 0;
|
||||
|
||||
if (!updateUBCALC(self, pCon, ref1, ref2, NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
single = SXGetDiffractometer();
|
||||
assert(single != NULL);
|
||||
|
||||
newUB = single->calcUBFromTwo(single,ref1, ref2, &err);
|
||||
if(newUB == NULL){
|
||||
switch(err){
|
||||
|
||||
newUB = single->calcUBFromTwo(single, ref1, ref2, &err);
|
||||
if (newUB == NULL) {
|
||||
switch (err) {
|
||||
case REFERR:
|
||||
SCWrite(pCon,"ERROR: one of reflections ID's is invalid",eError);
|
||||
return 0;
|
||||
break;
|
||||
SCWrite(pCon, "ERROR: one of reflections ID's is invalid", eError);
|
||||
return 0;
|
||||
break;
|
||||
case UBNOMEMORY:
|
||||
SCWrite(pCon,"ERROR: out of memory while calculating UB",eError);
|
||||
SCWrite(pCon, "ERROR: out of memory while calculating UB", eError);
|
||||
return 0;
|
||||
break;
|
||||
case REC_NO_VOLUME:
|
||||
SCWrite(pCon,"ERROR: bad cell constants",eError);
|
||||
SCWrite(pCon, "ERROR: bad cell constants", eError);
|
||||
return 0;
|
||||
break;
|
||||
default:
|
||||
SCWrite(pCon,"ERROR: unknown error on UB matrix calculation",eError);
|
||||
SCWrite(pCon, "ERROR: unknown error on UB matrix calculation",
|
||||
eError);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if(self->UB != NULL){
|
||||
if (self->UB != NULL) {
|
||||
mat_free(self->UB);
|
||||
}
|
||||
self->UB = newUB;
|
||||
@ -232,45 +252,49 @@ static int calcUB(pUBCALC self, SConnection *pCon,
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int sendUBToHKL(SConnection *pCon, SicsInterp *pSics,
|
||||
pHKL hkl, MATRIX UB){
|
||||
static int sendUBToHKL(SConnection * pCon, SicsInterp * pSics,
|
||||
pHKL hkl, MATRIX UB)
|
||||
{
|
||||
float ub[9];
|
||||
int i;
|
||||
|
||||
assert(hkl != NULL);
|
||||
|
||||
for(i = 0; i < 3; i++){
|
||||
ub[i] = UB[0][i];
|
||||
ub[i+3] = UB[1][i];
|
||||
ub[i+6] = UB[2][i];
|
||||
for (i = 0; i < 3; i++) {
|
||||
ub[i] = UB[0][i];
|
||||
ub[i + 3] = UB[1][i];
|
||||
ub[i + 6] = UB[2][i];
|
||||
}
|
||||
SetUB(hkl,ub);
|
||||
SetUB(hkl, ub);
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
}
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int setUBCalcParameters(pUBCALC self, SConnection *pCon,
|
||||
char *name, char *value){
|
||||
}
|
||||
|
||||
if(strcmp(name,"difftheta") == 0){
|
||||
if(!SCMatchRights(pCon,usUser)){
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int setUBCalcParameters(pUBCALC self, SConnection * pCon,
|
||||
char *name, char *value)
|
||||
{
|
||||
|
||||
if (strcmp(name, "difftheta") == 0) {
|
||||
if (!SCMatchRights(pCon, usUser)) {
|
||||
return 0;
|
||||
}
|
||||
self->allowedDeviation = atof(value);
|
||||
SCparChange(pCon);
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
} else if(strcmp(name,"maxindex") == 0){
|
||||
if(!SCMatchRights(pCon,usUser)){
|
||||
} else if (strcmp(name, "maxindex") == 0) {
|
||||
if (!SCMatchRights(pCon, usUser)) {
|
||||
return 0;
|
||||
}
|
||||
self->indexSearchLimit = atoi(value);
|
||||
SCparChange(pCon);
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
} else if(strcmp(name,"maxlist") == 0){
|
||||
if(!SCMatchRights(pCon,usUser)){
|
||||
} else if (strcmp(name, "maxlist") == 0) {
|
||||
if (!SCMatchRights(pCon, usUser)) {
|
||||
return 0;
|
||||
}
|
||||
self->maxSuggestions = atoi(value);
|
||||
@ -278,45 +302,56 @@ static int setUBCalcParameters(pUBCALC self, SConnection *pCon,
|
||||
SCSendOK(pCon);
|
||||
return 1;
|
||||
} else {
|
||||
SCWrite(pCon,"ERROR: subcommand not recognized",eError);
|
||||
SCWrite(pCon, "ERROR: subcommand not recognized", eError);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int getUBCalcParameters(pUBCALC self, SConnection *pCon, char *name){
|
||||
static int getUBCalcParameters(pUBCALC self, SConnection * pCon,
|
||||
char *name)
|
||||
{
|
||||
char pBueffel[255];
|
||||
int ret = 0;
|
||||
|
||||
if(strcmp(name,"difftheta") == 0){
|
||||
snprintf(pBueffel,255,"ubcalc.difftheta = %f",self->allowedDeviation);
|
||||
if (strcmp(name, "difftheta") == 0) {
|
||||
snprintf(pBueffel, 255, "ubcalc.difftheta = %f",
|
||||
self->allowedDeviation);
|
||||
ret = 1;
|
||||
} else if(strcmp(name,"maxindex") == 0){
|
||||
snprintf(pBueffel,255,"ubcalc.maxindex = %d", self->indexSearchLimit);
|
||||
} else if (strcmp(name, "maxindex") == 0) {
|
||||
snprintf(pBueffel, 255, "ubcalc.maxindex = %d",
|
||||
self->indexSearchLimit);
|
||||
ret = 1;
|
||||
} else if(strcmp(name,"maxlist") == 0){
|
||||
snprintf(pBueffel,255,"ubcalc.maxindex = %d", self->maxSuggestions);
|
||||
} else if (strcmp(name, "maxlist") == 0) {
|
||||
snprintf(pBueffel, 255, "ubcalc.maxindex = %d", self->maxSuggestions);
|
||||
ret = 1;
|
||||
} else {
|
||||
snprintf(pBueffel,255,"ERROR: subcommand not known");
|
||||
snprintf(pBueffel, 255, "ERROR: subcommand not known");
|
||||
}
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
SCWrite(pCon, pBueffel, eValue);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static void listPar(pUBCALC self, char *name, SConnection *pCon){
|
||||
static void listPar(pUBCALC self, char *name, SConnection * pCon)
|
||||
{
|
||||
char pBueffel[255];
|
||||
|
||||
snprintf(pBueffel,255,"%s.difftheta = %f", name, self->allowedDeviation);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
snprintf(pBueffel,255,"%s.maxindex = %d", name, self->indexSearchLimit);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
snprintf(pBueffel,255,"%s.maxlist = %d", name, self->maxSuggestions);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
snprintf(pBueffel, 255, "%s.difftheta = %f", name,
|
||||
self->allowedDeviation);
|
||||
SCWrite(pCon, pBueffel, eValue);
|
||||
snprintf(pBueffel, 255, "%s.maxindex = %d", name,
|
||||
self->indexSearchLimit);
|
||||
SCWrite(pCon, pBueffel, eValue);
|
||||
snprintf(pBueffel, 255, "%s.maxlist = %d", name, self->maxSuggestions);
|
||||
SCWrite(pCon, pBueffel, eValue);
|
||||
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int findIndex(pUBCALC self, SConnection *pCon, SicsInterp *pSics,
|
||||
int argc, char *argv[]){
|
||||
static int findIndex(pUBCALC self, SConnection * pCon, SicsInterp * pSics,
|
||||
int argc, char *argv[])
|
||||
{
|
||||
float two_theta;
|
||||
pMotor pMot = NULL;
|
||||
int status, numRef, i;
|
||||
@ -324,104 +359,109 @@ static int findIndex(pUBCALC self, SConnection *pCon, SicsInterp *pSics,
|
||||
Tcl_DString list;
|
||||
char pLine[255];
|
||||
double lambda;
|
||||
|
||||
if(argc > 2){
|
||||
|
||||
if (argc > 2) {
|
||||
two_theta = atof(argv[2]);
|
||||
} else {
|
||||
pMot = SXGetMotor(TwoTheta);
|
||||
if(pMot == NULL){
|
||||
SCWrite(pCon,"ERROR: cannot find stt motor",eError);
|
||||
if (pMot == NULL) {
|
||||
SCWrite(pCon, "ERROR: cannot find stt motor", eError);
|
||||
return 0;
|
||||
}
|
||||
MotorGetSoftPosition(pMot,pCon,&two_theta);
|
||||
MotorGetSoftPosition(pMot, pCon, &two_theta);
|
||||
}
|
||||
lambda = SXGetLambda();
|
||||
updateUBCALC(self,pCon,NULL,NULL,NULL);
|
||||
|
||||
updateUBCALC(self, pCon, NULL, NULL, NULL);
|
||||
|
||||
numRef = self->maxSuggestions;
|
||||
index = (refIndex *)malloc(numRef*sizeof(refIndex));
|
||||
if(index == NULL){
|
||||
SCWrite(pCon,"ERROR: out of memory allocating index list",eError);
|
||||
index = (refIndex *) malloc(numRef * sizeof(refIndex));
|
||||
if (index == NULL) {
|
||||
SCWrite(pCon, "ERROR: out of memory allocating index list", eError);
|
||||
return 0;
|
||||
}
|
||||
memset(index,0,numRef*sizeof(refIndex));
|
||||
memset(index, 0, numRef * sizeof(refIndex));
|
||||
|
||||
status = searchIndex(self->direct,lambda, two_theta,self->allowedDeviation,
|
||||
self->indexSearchLimit, index, numRef);
|
||||
status =
|
||||
searchIndex(self->direct, lambda, two_theta, self->allowedDeviation,
|
||||
self->indexSearchLimit, index, numRef);
|
||||
|
||||
if(status < 0){
|
||||
if(status == UBNOMEMORY){
|
||||
SCWrite(pCon,"ERROR: out of memory searching indices",eError);
|
||||
if (status < 0) {
|
||||
if (status == UBNOMEMORY) {
|
||||
SCWrite(pCon, "ERROR: out of memory searching indices", eError);
|
||||
return 0;
|
||||
} else if(status == REC_NO_VOLUME){
|
||||
SCWrite(pCon,"ERROR: bad cell parameters",eError);
|
||||
} else if (status == REC_NO_VOLUME) {
|
||||
SCWrite(pCon, "ERROR: bad cell parameters", eError);
|
||||
return 0;
|
||||
} else {
|
||||
SCWrite(pCon,"ERROR: unknown error code",eError);
|
||||
SCWrite(pCon, "ERROR: unknown error code", eError);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if(status < numRef) {
|
||||
if (status < numRef) {
|
||||
numRef = status;
|
||||
}
|
||||
Tcl_DStringInit(&list);
|
||||
for(i = 0; i < numRef; i++){
|
||||
snprintf(pLine,255," %3d %3d %3d %8.2f %8.2f %8.2f\r\n",
|
||||
(int)index[i].h, (int)index[i].k, (int)index[i].l,
|
||||
two_theta, index[i].t2calc,index[i].t2diff);
|
||||
Tcl_DStringAppend(&list,pLine,-1);
|
||||
for (i = 0; i < numRef; i++) {
|
||||
snprintf(pLine, 255, " %3d %3d %3d %8.2f %8.2f %8.2f\r\n",
|
||||
(int) index[i].h, (int) index[i].k, (int) index[i].l,
|
||||
two_theta, index[i].t2calc, index[i].t2diff);
|
||||
Tcl_DStringAppend(&list, pLine, -1);
|
||||
}
|
||||
if(numRef == 0){
|
||||
Tcl_DStringAppend(&list,"No suitable reflections found",-1);
|
||||
if (numRef == 0) {
|
||||
Tcl_DStringAppend(&list, "No suitable reflections found", -1);
|
||||
}
|
||||
SCWrite(pCon,Tcl_DStringValue(&list),eValue);
|
||||
SCWrite(pCon, Tcl_DStringValue(&list), eValue);
|
||||
|
||||
Tcl_DStringFree(&list);
|
||||
free(index);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------*/
|
||||
static int calcUB3Ref(pUBCALC self, SConnection *pCon,
|
||||
char *id1, char *id2, char *id3){
|
||||
static int calcUB3Ref(pUBCALC self, SConnection * pCon,
|
||||
char *id1, char *id2, char *id3)
|
||||
{
|
||||
double lambda;
|
||||
MATRIX newUB = NULL;
|
||||
int errCode = 1;
|
||||
char pBueffel[256];
|
||||
pSingleDiff single = NULL;
|
||||
|
||||
|
||||
lambda = SXGetLambda();
|
||||
if(!updateUBCALC(self, pCon, id1, id2, id3)){
|
||||
return 0;
|
||||
if (!updateUBCALC(self, pCon, id1, id2, id3)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
single = SXGetDiffractometer();
|
||||
assert(single != NULL);
|
||||
|
||||
newUB = single->calcUBFromThree(single,id1, id2, id3, &errCode);
|
||||
if(newUB == NULL){
|
||||
switch(errCode){
|
||||
|
||||
newUB = single->calcUBFromThree(single, id1, id2, id3, &errCode);
|
||||
if (newUB == NULL) {
|
||||
switch (errCode) {
|
||||
case REFERR:
|
||||
SCWrite(pCon,"ERROR: one of reflections ID's is invalid",eError);
|
||||
return 0;
|
||||
break;
|
||||
SCWrite(pCon, "ERROR: one of reflections ID's is invalid", eError);
|
||||
return 0;
|
||||
break;
|
||||
case UBNOMEMORY:
|
||||
SCWrite(pCon,"ERROR: out of memory calculating UB",eError);
|
||||
SCWrite(pCon, "ERROR: out of memory calculating UB", eError);
|
||||
break;
|
||||
case INVALID_LAMBDA:
|
||||
SCWrite(pCon,"ERROR: bad value for wavelength",eError);
|
||||
SCWrite(pCon, "ERROR: bad value for wavelength", eError);
|
||||
break;
|
||||
case NOTRIGHTHANDED:
|
||||
SCWrite(pCon,"ERROR: reflections are coplanar or do not form a right handed system",
|
||||
eError);
|
||||
SCWrite(pCon,
|
||||
"ERROR: reflections are coplanar or do not form a right handed system",
|
||||
eError);
|
||||
break;
|
||||
default:
|
||||
SCWrite(pCon,"ERROR: unknown error code from UB calculation",eError);
|
||||
SCWrite(pCon, "ERROR: unknown error code from UB calculation",
|
||||
eError);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
} else {
|
||||
if(self->UB != NULL){
|
||||
if (self->UB != NULL) {
|
||||
mat_free(self->UB);
|
||||
}
|
||||
self->UB = newUB;
|
||||
@ -429,109 +469,117 @@ static int calcUB3Ref(pUBCALC self, SConnection *pCon,
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*/
|
||||
static int cellFromUBWrapper(pUBCALC self, SConnection *pCon){
|
||||
static int cellFromUBWrapper(pUBCALC self, SConnection * pCon)
|
||||
{
|
||||
int status;
|
||||
char pBueffel[256];
|
||||
lattice direct;
|
||||
const double *ub;
|
||||
MATRIX UB;
|
||||
int i;
|
||||
|
||||
UB = mat_creat(3,3,UNIT_MATRIX);
|
||||
|
||||
UB = mat_creat(3, 3, UNIT_MATRIX);
|
||||
ub = SXGetUB();
|
||||
for(i = 0; i < 3; i++){
|
||||
UB[0][i] = ub[i];
|
||||
UB[1][i] = ub[i+3];
|
||||
UB[2][i] = ub[i+6];
|
||||
for (i = 0; i < 3; i++) {
|
||||
UB[0][i] = ub[i];
|
||||
UB[1][i] = ub[i + 3];
|
||||
UB[2][i] = ub[i + 6];
|
||||
}
|
||||
|
||||
status = cellFromUB(UB,&direct);
|
||||
|
||||
status = cellFromUB(UB, &direct);
|
||||
mat_free(UB);
|
||||
|
||||
if(status < 0){
|
||||
switch(status){
|
||||
|
||||
if (status < 0) {
|
||||
switch (status) {
|
||||
case CELLNOMEMORY:
|
||||
SCWrite(pCon,"ERROR: out of memory while calculating cell",eError);
|
||||
SCWrite(pCon, "ERROR: out of memory while calculating cell", eError);
|
||||
break;
|
||||
default:
|
||||
SCWrite(pCon,"ERROR: unknown error calculating cell",eError);
|
||||
SCWrite(pCon, "ERROR: unknown error calculating cell", eError);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
} else {
|
||||
snprintf(pBueffel,255,"%f %f %f %f %f %f",
|
||||
direct.a, direct.b, direct.c,
|
||||
direct.alpha, direct.beta, direct.gamma);
|
||||
SCWrite(pCon,pBueffel,eValue);
|
||||
snprintf(pBueffel, 255, "%f %f %f %f %f %f",
|
||||
direct.a, direct.b, direct.c,
|
||||
direct.alpha, direct.beta, direct.gamma);
|
||||
SCWrite(pCon, pBueffel, eValue);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------*/
|
||||
int UBCalcWrapper(SConnection *pCon, SicsInterp *pSics, void *pData,
|
||||
int argc, char *argv[]){
|
||||
pUBCALC self = (pUBCALC)pData;
|
||||
int UBCalcWrapper(SConnection * pCon, SicsInterp * pSics, void *pData,
|
||||
int argc, char *argv[])
|
||||
{
|
||||
pUBCALC self = (pUBCALC) pData;
|
||||
char pBuffer[512];
|
||||
|
||||
|
||||
assert(self);
|
||||
if(argc < 2){
|
||||
SCWrite(pCon,"Insuffcient number of arguments to ubcalc",eError);
|
||||
return 0;
|
||||
if (argc < 2) {
|
||||
SCWrite(pCon, "Insuffcient number of arguments to ubcalc", eError);
|
||||
return 0;
|
||||
}
|
||||
strtolower(argv[1]);
|
||||
|
||||
if(strcmp(argv[1],"listub") == 0){
|
||||
listUB(pCon,self->UB);
|
||||
if (strcmp(argv[1], "listub") == 0) {
|
||||
listUB(pCon, self->UB);
|
||||
return 1;
|
||||
} else if(strcmp(argv[1],"ub2ref") == 0){
|
||||
if(argc < 4){
|
||||
SCWrite(pCon,"Insuffcient number of arguments to ubcalc ub2ref",eError);
|
||||
return 0;
|
||||
}
|
||||
return calcUB(self,pCon, argv[2], argv[3]);
|
||||
} else if(strcmp(argv[1],"ub3ref") == 0){
|
||||
if(argc < 5){
|
||||
SCWrite(pCon,"Insuffcient number of arguments to ubcalc ub3ref",eError);
|
||||
return 0;
|
||||
}
|
||||
return calcUB3Ref(self,pCon,argv[2],argv[3],argv[4]);
|
||||
} else if(strcmp(argv[1],"cellub") == 0){
|
||||
return cellFromUBWrapper(self,pCon);
|
||||
}else if(strcmp(argv[1],"list") == 0){
|
||||
listUB(pCon,self->UB);
|
||||
listPar(self,argv[0],pCon);
|
||||
} else if (strcmp(argv[1], "ub2ref") == 0) {
|
||||
if (argc < 4) {
|
||||
SCWrite(pCon, "Insuffcient number of arguments to ubcalc ub2ref",
|
||||
eError);
|
||||
return 0;
|
||||
}
|
||||
return calcUB(self, pCon, argv[2], argv[3]);
|
||||
} else if (strcmp(argv[1], "ub3ref") == 0) {
|
||||
if (argc < 5) {
|
||||
SCWrite(pCon, "Insuffcient number of arguments to ubcalc ub3ref",
|
||||
eError);
|
||||
return 0;
|
||||
}
|
||||
return calcUB3Ref(self, pCon, argv[2], argv[3], argv[4]);
|
||||
} else if (strcmp(argv[1], "cellub") == 0) {
|
||||
return cellFromUBWrapper(self, pCon);
|
||||
} else if (strcmp(argv[1], "list") == 0) {
|
||||
listUB(pCon, self->UB);
|
||||
listPar(self, argv[0], pCon);
|
||||
return 1;
|
||||
} else if(strcmp(argv[1],"activate") == 0){
|
||||
return sendUBToHKL(pCon,pSics,self->hkl,self->UB);
|
||||
} else if(strcmp(argv[1],"index") == 0){
|
||||
return findIndex(self,pCon,pSics,argc, argv);
|
||||
} else if (strcmp(argv[1], "activate") == 0) {
|
||||
return sendUBToHKL(pCon, pSics, self->hkl, self->UB);
|
||||
} else if (strcmp(argv[1], "index") == 0) {
|
||||
return findIndex(self, pCon, pSics, argc, argv);
|
||||
} else {
|
||||
if(argc > 2){
|
||||
return setUBCalcParameters(self,pCon,argv[1],argv[2]);
|
||||
if (argc > 2) {
|
||||
return setUBCalcParameters(self, pCon, argv[1], argv[2]);
|
||||
} else {
|
||||
return getUBCalcParameters(self,pCon,argv[1]);
|
||||
return getUBCalcParameters(self, pCon, argv[1]);
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
reflection getReflection(void *ubcalc, int no){
|
||||
pUBCALC self = (pUBCALC)ubcalc;
|
||||
|
||||
assert(self != NULL);
|
||||
|
||||
switch(no){
|
||||
case 0:
|
||||
return self->r1;
|
||||
break;
|
||||
case 1:
|
||||
return self->r2;
|
||||
break;
|
||||
case 2:
|
||||
return self->r3;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
reflection getReflection(void *ubcalc, int no)
|
||||
{
|
||||
pUBCALC self = (pUBCALC) ubcalc;
|
||||
|
||||
assert(self != NULL);
|
||||
|
||||
switch (no) {
|
||||
case 0:
|
||||
return self->r1;
|
||||
break;
|
||||
case 1:
|
||||
return self->r2;
|
||||
break;
|
||||
case 2:
|
||||
return self->r3;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user