879 lines
23 KiB
C
879 lines
23 KiB
C
/**
|
|
* Reflection list: a configurable list of reflections and
|
|
* their setting angles. To be used for four circle and possibly
|
|
* TAS diffraction.
|
|
*
|
|
* copyright: see file COPYRIGHT
|
|
*
|
|
* Mark Koennecke, July 2008
|
|
*/
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include "reflist.h"
|
|
#include "sicshipadaba.h"
|
|
#include "stptok.h"
|
|
|
|
#define INAME "index"
|
|
#define ANAME "angles"
|
|
#define FLAG "flag"
|
|
static char undef[] = "Undefined";
|
|
#define IDXFMT " %8.4f"
|
|
#define ANGFMT " %8.2f"
|
|
/*----------------------------------------------------------------------*/
|
|
typedef struct {
|
|
int idxCount;
|
|
int angCount;
|
|
int count;
|
|
} RLPriv, *pRLPriv;
|
|
/*----------------------------------------------------------------------
|
|
* The point of the code below and the callback is to update the
|
|
* configuration counts whenever the corresponding parameters
|
|
* are changed.
|
|
* ---------------------------------------------------------------------*/
|
|
static void UpdateConfiguration(pSICSOBJ refl)
|
|
{
|
|
pRLPriv priv = refl->pPrivate;
|
|
hdbValue v;
|
|
char *pPtr = NULL, token[50];
|
|
|
|
|
|
SICSHdbGetPar(refl, NULL, "indexheader", &v);
|
|
pPtr = v.v.text;
|
|
priv->idxCount = 0;
|
|
while ((pPtr = stptok(pPtr, token, 50, ",")) != NULL) {
|
|
priv->idxCount++;
|
|
}
|
|
|
|
SICSHdbGetPar(refl, NULL, "anglesheader", &v);
|
|
pPtr = v.v.text;
|
|
priv->angCount = 0;
|
|
while ((pPtr = stptok(pPtr, token, 50, ",")) != NULL) {
|
|
priv->angCount++;
|
|
}
|
|
ClearReflectionList(refl);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static hdbCallbackReturn CalcConfiguration(pHdb node, void *userData,
|
|
pHdbMessage mm)
|
|
{
|
|
|
|
if (GetHdbSetMessage(mm) != NULL) {
|
|
/*
|
|
* This is after the normal SICS parameter SetUpdateCallback
|
|
* which already updated the node
|
|
*/
|
|
UpdateConfiguration((pSICSOBJ) userData);
|
|
}
|
|
return hdbContinue;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int SaveRefList(void *data, char *name, FILE * fd)
|
|
{
|
|
int i;
|
|
double ang[4], hkl[3];
|
|
pSICSOBJ self = data;
|
|
|
|
SaveSICSOBJ(data, name, fd);
|
|
for (i = 0; i < ReflectionListCount(self); i++) {
|
|
memset(hkl, 0, 3 * sizeof(double));
|
|
memset(ang, 0, 4 * sizeof(double));
|
|
GetRefIndex(self, i, hkl);
|
|
GetRefAngles(self, i, ang);
|
|
fprintf(fd, "%s addax %f %f %f %f %f %f %f\n", name,
|
|
hkl[0], hkl[1], hkl[2], ang[0], ang[1], ang[2], ang[3]);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
pSICSOBJ MakeReflectionListInt(char *name)
|
|
{
|
|
pSICSOBJ pNew = NULL;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = NULL;
|
|
|
|
pNew = MakeSICSOBJ(name, "ReflectionList");
|
|
priv = malloc(sizeof(RLPriv));
|
|
if (pNew == NULL || priv == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
pNew->pPrivate = priv;
|
|
pNew->KillPrivate = DefaultKill;
|
|
pNew->pDes->SaveStatus = SaveRefList;
|
|
|
|
v = MakeHdbText("h,k,l");
|
|
node = MakeSICSHdbPar("indexheader", usMugger, v);
|
|
AppendHipadabaCallback(node, MakeHipadabaCallback(CalcConfiguration,
|
|
pNew, NULL));
|
|
AddHipadabaChild(pNew->objectNode, node, NULL);
|
|
priv->idxCount = 3;
|
|
|
|
v = MakeHdbText("stt,om,chi,phi");
|
|
node = MakeSICSHdbPar("anglesheader", usMugger, v);
|
|
AppendHipadabaCallback(node, MakeHipadabaCallback(CalcConfiguration,
|
|
pNew, NULL));
|
|
AddHipadabaChild(pNew->objectNode, node, NULL);
|
|
priv->angCount = 4;
|
|
priv->count = 0;
|
|
|
|
v = makeHdbValue(HIPNONE, 0);
|
|
node = MakeSICSHdbPar("list", usMugger, v);
|
|
AddHipadabaChild(pNew->objectNode, node, NULL);
|
|
|
|
return pNew;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int MakeCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
int status;
|
|
|
|
status = NewListReflection(self);
|
|
if (status >= 0) {
|
|
SCPrintf(pCon, eValue, "newref = %4.4d", status);
|
|
return 1;
|
|
} else {
|
|
SCWrite(pCon, "ERROR: failed to create reflection", eError);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int ClearCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
ClearReflectionList(self);
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
static int AddIndexCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
char path[80];
|
|
int status;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need indexes as arguments", eError);
|
|
return 0;
|
|
}
|
|
|
|
status = NewListReflection(self);
|
|
snprintf(path, 80, "list/%4.4d/%s", status, INAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, par[0]->value.v.text, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to indices",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
void AddRefIdx(pSICSOBJ refl, double hkl[])
|
|
{
|
|
int status;
|
|
hdbValue v;
|
|
char path[80];
|
|
pHdb node;
|
|
|
|
status = NewListReflection(refl);
|
|
snprintf(path, 80, "list/%4.4d/%s", status, INAME);
|
|
node = GetHipadabaNode(refl->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
v = MakeHdbFloatArray(3, hkl);
|
|
SetHipadabaPar(node, v, NULL);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
void AddRefIdxAng(pSICSOBJ refl, double hkl[], double ang[])
|
|
{
|
|
int status;
|
|
hdbValue v;
|
|
char path[80];
|
|
pHdb node;
|
|
|
|
status = NewListReflection(refl);
|
|
snprintf(path, 80, "list/%4.4d/%s", status, INAME);
|
|
node = GetHipadabaNode(refl->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
v = MakeHdbFloatArray(3, hkl);
|
|
SetHipadabaPar(node, v, NULL);
|
|
|
|
snprintf(path, 80, "list/%4.4d/%s", status, ANAME);
|
|
node = GetHipadabaNode(refl->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
v = MakeHdbFloatArray(3, ang);
|
|
SetHipadabaPar(node, v, NULL);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
static int AddAnglesCmd(pSICSOBJ self, SConnection * pCon,
|
|
pHdb commandNode, pHdb par[], int nPar)
|
|
{
|
|
char path[80];
|
|
int status;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need angles as arguments", eError);
|
|
return 0;
|
|
}
|
|
|
|
status = NewListReflection(self);
|
|
snprintf(path, 80, "list/%4.4d/%s", status, ANAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, par[0]->value.v.text, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to angles",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
static int AddIndexesAnglesCmd(pSICSOBJ self, SConnection * pCon,
|
|
pHdb commandNode, pHdb par[], int nPar)
|
|
{
|
|
char path[80];
|
|
int status, i;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
char *pPtr = NULL;
|
|
pRLPriv priv = self->pPrivate;
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need indexes/angles as arguments", eError);
|
|
return 0;
|
|
}
|
|
|
|
status = NewListReflection(self);
|
|
snprintf(path, 80, "list/%4.4d/%s", status, INAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, par[0]->value.v.text, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to indices",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
|
|
/* advance pointer beyond indices */
|
|
pPtr = par[0]->value.v.text;
|
|
for (i = 0; i < priv->idxCount; i++) {
|
|
pPtr = stptok(pPtr, path, 80, " ");
|
|
}
|
|
|
|
snprintf(path, 80, "list/%4.4d/%s", status, ANAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, pPtr, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to angles",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int DelCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
char path[132];
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need id to delete as argument", eError);
|
|
return 0;
|
|
}
|
|
snprintf(path, 132, "list/%s", par[0]->value.v.text);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
if (node != NULL) {
|
|
DeleteHipadabaNode(node, pCon);
|
|
return 1;
|
|
}
|
|
SCWrite(pCon, "ERROR: reflection not found", eError);
|
|
return 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int FlagCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
char path[132];
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need id to flag for", eError);
|
|
return 0;
|
|
}
|
|
snprintf(path, 132, "list/%s/%s", par[0]->value.v.text, FLAG);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
if (node == NULL) {
|
|
SCPrintf(pCon, eError, "ERROR: bad ID %s", par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
if (nPar < 2) {
|
|
SCPrintf(pCon, eValue, "%s.%s.flag = %d", self->pDes->name,
|
|
par[0]->value.v.text, node->value.v.intValue);
|
|
return 1;
|
|
} else {
|
|
SetHipadabaPar(node, par[1]->value, pCon);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int ShowCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
char path[132], num[20];
|
|
char data[1024];
|
|
hdbValue v;
|
|
int i;
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need id for reflection to show", eError);
|
|
return 0;
|
|
}
|
|
snprintf(path, 132, "list/%s/%s", par[0]->value.v.text, FLAG);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
if (node == NULL) {
|
|
SCPrintf(pCon, eError, "ERROR: bad ID %s", par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
GetHipadabaPar(node, &v, pCon);
|
|
snprintf(data, 1024, "%s %d", par[0]->value.v.text, v.v.intValue);
|
|
|
|
snprintf(path, 132, "list/%s/%s", par[0]->value.v.text, INAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
GetHipadabaPar(node, &v, pCon);
|
|
for (i = 0; i < v.arrayLength; i++) {
|
|
snprintf(num, 20, " %f", v.v.floatArray[i]);
|
|
strncat(data, num, 1024);
|
|
}
|
|
|
|
snprintf(path, 132, "list/%s/%s", par[0]->value.v.text, ANAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
GetHipadabaPar(node, &v, pCon);
|
|
for (i = 0; i < v.arrayLength; i++) {
|
|
snprintf(num, 20, " %f", v.v.floatArray[i]);
|
|
strncat(data, num, 1024);
|
|
}
|
|
SCWrite(pCon, data, eValue);
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int ListCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
char buffer[132], path[132], *pPtr, token[20], entry[20];
|
|
pRLPriv priv = self->pPrivate;
|
|
int i;
|
|
pHdb node = NULL, data;
|
|
pDynString txt;
|
|
|
|
SCStartBuffering(pCon);
|
|
/*
|
|
* build header
|
|
*/
|
|
strcpy(buffer, " ID FLAG");
|
|
node = GetHipadabaNode(self->objectNode, "indexheader");
|
|
assert(node != NULL);
|
|
pPtr = node->value.v.text;
|
|
while ((pPtr = stptok(pPtr, token, 20, ",")) != NULL) {
|
|
snprintf(entry, 20, " %8s", token);
|
|
strncat(buffer, entry, 132);
|
|
}
|
|
node = GetHipadabaNode(self->objectNode, "anglesheader");
|
|
assert(node != NULL);
|
|
pPtr = node->value.v.text;
|
|
while ((pPtr = stptok(pPtr, token, 20, ",")) != NULL) {
|
|
snprintf(entry, 20, " %8s", token);
|
|
strncat(buffer, entry, 132);
|
|
}
|
|
SCWrite(pCon, buffer, eValue);
|
|
|
|
node = GetHipadabaNode(self->objectNode, "list");
|
|
node = node->child;
|
|
while (node != NULL) {
|
|
data = GetHipadabaNode(node, FLAG);
|
|
assert(data != NULL);
|
|
snprintf(buffer, 132, " %5s %4d", node->name, data->value.v.intValue);
|
|
data = GetHipadabaNode(node, INAME);
|
|
for (i = 0; i < priv->idxCount; i++) {
|
|
sprintf(entry, IDXFMT, data->value.v.floatArray[i]);
|
|
strncat(buffer, entry, 132);
|
|
}
|
|
data = GetHipadabaNode(node, ANAME);
|
|
for (i = 0; i < priv->angCount; i++) {
|
|
sprintf(entry, ANGFMT, data->value.v.floatArray[i]);
|
|
strncat(buffer, entry, 132);
|
|
}
|
|
SCWrite(pCon, buffer, eValue);
|
|
node = node->next;
|
|
}
|
|
|
|
txt = SCEndBuffering(pCon);
|
|
SCWrite(pCon, GetCharArray(txt), eValue);
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int NamesCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
char buffer[132];
|
|
pHdb node = NULL;
|
|
pDynString txt;
|
|
|
|
SCStartBuffering(pCon);
|
|
|
|
node = GetHipadabaNode(self->objectNode, "list");
|
|
node = node->child;
|
|
while (node != NULL) {
|
|
snprintf(buffer, 132, "%s", node->name);
|
|
SCWrite(pCon, buffer, eValue);
|
|
node = node->next;
|
|
}
|
|
|
|
txt = SCEndBuffering(pCon);
|
|
SCWrite(pCon, GetCharArray(txt), eValue);
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
static int SetIndexCmd(pSICSOBJ self, SConnection * pCon, pHdb commandNode,
|
|
pHdb par[], int nPar)
|
|
{
|
|
char path[80];
|
|
int status;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
char *pPtr = NULL, refl[20];
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need id and indexes as arguments", eError);
|
|
return 0;
|
|
}
|
|
|
|
pPtr = par[0]->value.v.text;
|
|
pPtr = stptok(pPtr, refl, 20, " ");
|
|
|
|
snprintf(path, 80, "list/%s/%s", refl, INAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
assert(node != NULL);
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, pPtr, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to indices",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
static int SetAnglesCmd(pSICSOBJ self, SConnection * pCon,
|
|
pHdb commandNode, pHdb par[], int nPar)
|
|
{
|
|
char path[80];
|
|
int status;
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
char *pPtr = NULL, refl[20];
|
|
|
|
if (nPar < 1) {
|
|
SCWrite(pCon, "ERROR: need id and angles as arguments", eError);
|
|
return 0;
|
|
}
|
|
|
|
pPtr = par[0]->value.v.text;
|
|
pPtr = stptok(pPtr, refl, 20, " ");
|
|
|
|
snprintf(path, 80, "list/%s/%s", refl, ANAME);
|
|
node = GetHipadabaNode(self->objectNode, path);
|
|
if (node == NULL) {
|
|
SCPrintf(pCon, eError, "ERROR: reflection with ID %s not found", refl);
|
|
return 0;
|
|
}
|
|
|
|
cloneHdbValue(&node->value, &v);
|
|
if (!readHdbValue(&v, pPtr, path, 80)) {
|
|
SCPrintf(pCon, eError, "ERROR: failed to convert %s to angles",
|
|
par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
SetHipadabaPar(node, v, pCon);
|
|
ReleaseHdbValue(&v);
|
|
return 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
int MakeReflectionList(SConnection * pCon, SicsInterp * pSics,
|
|
void *data, int argc, char *argv[])
|
|
{
|
|
pSICSOBJ pNew = NULL;
|
|
pHdb cmd;
|
|
|
|
if (argc < 2) {
|
|
SCWrite(pCon, "ERROR: need name of reflection list", eError);
|
|
return 0;
|
|
}
|
|
pNew = CreateReflectionList(pCon, pSics, argv[1]);
|
|
if (pNew == NULL) {
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
pSICSOBJ CreateReflectionList(SConnection * pCon, SicsInterp * pSics,
|
|
char *name)
|
|
{
|
|
pSICSOBJ pNew = NULL;
|
|
pHdb cmd;
|
|
|
|
pNew = MakeReflectionListInt(name);
|
|
if (pNew == NULL) {
|
|
SCWrite(pCon, "ERROR: failed to create reflection list", eError);
|
|
return 0;
|
|
}
|
|
|
|
/* command initialization */
|
|
AddSICSHdbPar(pNew->objectNode, "make", usUser, MakeSICSFunc(MakeCmd));
|
|
|
|
AddSICSHdbPar(pNew->objectNode, "clear", usUser, MakeSICSFunc(ClearCmd));
|
|
|
|
AddSICSHdbPar(pNew->objectNode, "print", usUser, MakeSICSFunc(ListCmd));
|
|
|
|
AddSICSHdbPar(pNew->objectNode, "names", usUser, MakeSICSFunc(NamesCmd));
|
|
|
|
cmd =
|
|
AddSICSHdbPar(pNew->objectNode, "del", usUser, MakeSICSFunc(DelCmd));
|
|
AddSICSHdbPar(cmd, "id", usUser, MakeHdbText(""));
|
|
|
|
cmd =
|
|
AddSICSHdbPar(pNew->objectNode, "addx", usUser,
|
|
MakeSICSFunc(AddIndexCmd));
|
|
AddSICSHdbPar(cmd, "args", usUser, MakeHdbText(""));
|
|
|
|
cmd =
|
|
AddSICSHdbPar(pNew->objectNode, "setx", usUser,
|
|
MakeSICSFunc(SetIndexCmd));
|
|
AddSICSHdbPar(cmd, "args", usUser, MakeHdbText(""));
|
|
|
|
cmd =
|
|
AddSICSHdbPar(pNew->objectNode, "adda", usUser,
|
|
MakeSICSFunc(AddAnglesCmd));
|
|
AddSICSHdbPar(cmd, "args", usUser, MakeHdbText(""));
|
|
|
|
cmd =
|
|
AddSICSHdbPar(pNew->objectNode, "seta", usUser,
|
|
MakeSICSFunc(SetAnglesCmd));
|
|
AddSICSHdbPar(cmd, "args", usUser, MakeHdbText(""));
|
|
|
|
cmd = AddSICSHdbPar(pNew->objectNode, "addax", usUser,
|
|
MakeSICSFunc(AddIndexesAnglesCmd));
|
|
AddSICSHdbPar(cmd, "args", usUser, MakeHdbText(""));
|
|
|
|
cmd = AddSICSHdbPar(pNew->objectNode, "flag", usUser,
|
|
MakeSICSFunc(FlagCmd));
|
|
AddSICSHdbPar(cmd, "id", usUser, MakeHdbText(""));
|
|
AddSICSHdbPar(cmd, "value", usUser, MakeHdbInt(0));
|
|
|
|
cmd = AddSICSHdbPar(pNew->objectNode, "show", usUser,
|
|
MakeSICSFunc(ShowCmd));
|
|
AddSICSHdbPar(cmd, "id", usUser, MakeHdbText(""));
|
|
|
|
AddCommand(pSics, name, InterInvokeSICSOBJ, KillSICSOBJ, pNew);
|
|
return pNew;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
void ClearReflectionList(pSICSOBJ refl)
|
|
{
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
node = GetHipadabaNode(refl->objectNode, "list");
|
|
assert(node);
|
|
DeleteHipadabaNode(node, NULL);
|
|
v = makeHdbValue(HIPNONE, 0);
|
|
node = MakeSICSHdbPar("list", usMugger, v);
|
|
AddHipadabaChild(refl->objectNode, node, NULL);
|
|
priv->count = 0;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
int ReflectionListCount(pSICSOBJ refl)
|
|
{
|
|
pHdb node = NULL;
|
|
|
|
node = GetHipadabaNode(refl->objectNode, "list");
|
|
assert(node);
|
|
return CountHdbChildren(node);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
int NewListReflection(pSICSOBJ refl)
|
|
{
|
|
int count;
|
|
char path[20];
|
|
pHdb listNode = NULL, node = NULL, refNode = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
listNode = GetHipadabaNode(refl->objectNode, "list");
|
|
assert(listNode);
|
|
|
|
count = priv->count;
|
|
priv->count++;
|
|
snprintf(path, 20, "%4.4d", count);
|
|
node = MakeHipadabaNode(path, HIPNONE, 0);
|
|
AddHipadabaChild(listNode, node, NULL);
|
|
|
|
v = makeHdbValue(HIPFLOATAR, priv->idxCount);
|
|
AddSICSHdbPar(node, INAME, usUser, v);
|
|
|
|
v = makeHdbValue(HIPFLOATAR, priv->angCount);
|
|
AddSICSHdbPar(node, ANAME, usUser, v);
|
|
|
|
v = makeHdbValue(HIPINT, 0);
|
|
AddSICSHdbPar(node, FLAG, usUser, v);
|
|
return count;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
static pHdb findReflection(pSICSOBJ refl, int idx)
|
|
{
|
|
pHdb node = NULL;
|
|
int count = 0;
|
|
|
|
if (idx < 0) {
|
|
return node;
|
|
}
|
|
|
|
node = GetHipadabaNode(refl->objectNode, "list");
|
|
assert(node);
|
|
|
|
node = node->child;
|
|
while (node != NULL && count != idx) {
|
|
count++;
|
|
node = node->next;
|
|
}
|
|
return node;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
void DelListReflection(pSICSOBJ refl, int idx)
|
|
{
|
|
pHdb node = NULL;
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
DeleteHipadabaNode(node, NULL);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------*/
|
|
int SetRefIndex(pSICSOBJ refl, int idx, double hkl[])
|
|
{
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, INAME);
|
|
assert(node);
|
|
v = MakeHdbFloatArray(priv->idxCount, hkl);
|
|
SetHipadabaPar(node, v, NULL);
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------*/
|
|
int SetRefAngles(pSICSOBJ refl, int idx, double ang[])
|
|
{
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, ANAME);
|
|
assert(node);
|
|
v = MakeHdbFloatArray(priv->angCount, ang);
|
|
SetHipadabaPar(node, v, NULL);
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------*/
|
|
int SetRefFlag(pSICSOBJ refl, int idx, int val)
|
|
{
|
|
pHdb node = NULL;
|
|
hdbValue v;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, FLAG);
|
|
assert(node);
|
|
v = MakeHdbInt(val);
|
|
SetHipadabaPar(node, v, NULL);
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
int GetRefIndex(pSICSOBJ refl, int idx, double hkl[])
|
|
{
|
|
pHdb node = NULL;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, INAME);
|
|
assert(node);
|
|
memcpy(hkl, node->value.v.floatArray, priv->idxCount * sizeof(double));
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
int GetRefIndexID(pSICSOBJ refl, char *id, double hkl[])
|
|
{
|
|
pHdb node = NULL;
|
|
pRLPriv priv = refl->pPrivate;
|
|
char path[132];
|
|
|
|
snprintf(path, 132, "list/%s", id);
|
|
node = GetHipadabaNode(refl->objectNode, path);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, INAME);
|
|
assert(node);
|
|
memcpy(hkl, node->value.v.floatArray, priv->idxCount * sizeof(double));
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
int GetRefAngles(pSICSOBJ refl, int idx, double ang[])
|
|
{
|
|
pHdb node = NULL;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, ANAME);
|
|
assert(node);
|
|
memcpy(ang, node->value.v.floatArray, priv->angCount * sizeof(double));
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
int GetRefAnglesID(pSICSOBJ refl, char *id, double hkl[])
|
|
{
|
|
pHdb node = NULL;
|
|
pRLPriv priv = refl->pPrivate;
|
|
char path[132];
|
|
|
|
snprintf(path, 132, "list/%s", id);
|
|
node = GetHipadabaNode(refl->objectNode, path);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, ANAME);
|
|
assert(node);
|
|
memcpy(hkl, node->value.v.floatArray, priv->angCount * sizeof(double));
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------------*/
|
|
int GetRefFlag(pSICSOBJ refl, int idx)
|
|
{
|
|
pHdb node = NULL;
|
|
pRLPriv priv = refl->pPrivate;
|
|
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
node = GetHipadabaNode(node, FLAG);
|
|
assert(node);
|
|
return node->value.v.intValue;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------*/
|
|
char *GetRefName(pSICSOBJ refl, int idx)
|
|
{
|
|
pHdb node = NULL;
|
|
|
|
node = findReflection(refl, idx);
|
|
if (node != NULL) {
|
|
return node->name;
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|