linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Introduced a general Hipadaba table module and modified the four

Browse Source 
circle codes to use it.
- Added to functions to histmem, getdelay and formattof,  to support new HM
- Removed obsolete mesure.*
This commit is contained in:
koennecke
2009-03-16 14:24:34 +00:00
parent 299ad44be3
commit 3e8b11675a
15 changed files with 948 additions and 2519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
fourmess.c
View File

@ -41,7 +41,7 @@ extern void SNXFormatTime(char *pBueffel, int iLen);
typedef struct { typedef struct {
FILE *profFile; /* file with reflection profiles, ccl */ FILE *profFile; /* file with reflection profiles, ccl */
FILE *hklFile; /* file with integrated intensities */ FILE *hklFile; /* file with integrated intensities */
int stepTable; /* table with the scan parameters */ pSICSOBJ stepTable; /* table with the scan parameters */
char *currentFileRoot; char *currentFileRoot;
pSICSOBJ messList; pSICSOBJ messList;
pHdb currentRefl; /* the current reflection being measured */ pHdb currentRefl; /* the current reflection being measured */
@ -90,7 +90,7 @@ static int FourMessAction(SConnection * pCon, SicsInterp * pSics,
} }
if (strcmp(argv[1], "table") == 0) { if (strcmp(argv[1], "table") == 0) {
return HandleFourCircleCommands(&priv->stepTable, pCon, return HandleFourCircleCommands(priv->stepTable, pCon,
argc, argv, &err); argc, argv, &err);
} }
@ -774,7 +774,7 @@ static int FourMessSave(void *data, char *name, FILE * fd)
pFourMess priv = self->pPrivate; pFourMess priv = self->pPrivate;
SaveSICSOBJ(data, name, fd); SaveSICSOBJ(data, name, fd);
SaveFourCircleTable(priv->stepTable, name, fd); priv->stepTable->pDes->SaveStatus(priv->stepTable,"fmess table", fd);
return 1; return 1;
} }
@ -878,6 +878,7 @@ void InstallFourMess(SConnection * pCon, SicsInterp * pSics)
MakeHipadabaCallback(SetScannerCB, priv, NULL)); MakeHipadabaCallback(SetScannerCB, priv, NULL));
priv->pScanner = FindCommandData(pSics, "xxxscan", "ScanObject"); priv->pScanner = FindCommandData(pSics, "xxxscan", "ScanObject");
AddHipadabaChild(pNew->objectNode, priv->stepTable->objectNode,pCon);
AddCommand(pSics, "fmess", FourMessAction, KillSICSOBJ, pNew); AddCommand(pSics, "fmess", FourMessAction, KillSICSOBJ, pNew);
} }

432
fourtable.c
View File

@ -6,196 +6,105 @@
copyright: see copyright.h copyright: see copyright.h
Mark Koennecke, February 2005 Mark Koennecke, February 2005
Massively reworked to make use of the new hdbtable object.
Mark Koennecke, March 2009
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include "sics.h" #include "sics.h"
#include "fortify.h" #include "hdbtable.h"
#include "lld.h" #include <sicshipadaba.h>
#include <tcl.h>
#include "splitter.h"
#include "fourtable.h" #include "fourtable.h"
/*====================== table entry ===================================*/
typedef struct {
double twoThetaEnd;
char scanVar[30];
double step;
int np;
float preset;
} FourTableEntry, *pFourTableEntry;
/*==================== functions =======================================*/ /*==================== functions =======================================*/
int MakeFourCircleTable() pSICSOBJ MakeFourCircleTable()
{ {
return LLDcreate(sizeof(FourTableEntry)); pSICSOBJ table = NULL;
pHdb node = NULL;
table = MakeHdbTable("fmesstable","FourMess");
node = GetHipadabaNode(table->objectNode,"template");
assert(node != NULL);
AddSICSHdbPar(node, "endTTH", usUser, MakeHdbFloat(.0));
AddSICSHdbPar(node, "scanvar", usUser, MakeHdbText(""));
AddSICSHdbPar(node, "step", usUser, MakeHdbFloat(.0));
AddSICSHdbPar(node, "np", usUser, MakeHdbInt(0));
AddSICSHdbPar(node, "preset", usUser, MakeHdbFloat(.0));
ReadTableTemplate(table, NULL);
return table;
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
void DeleteFourCircleTable(int handle) void DeleteFourCircleTable(pSICSOBJ data)
{ {
LLDdelete(handle); KillSICSOBJ(data);
} }
/*------------------------------------------------------------------------*/
static void printList(int handle, SConnection * pCon)
{
FourTableEntry entry;
char pBueffel[132];
int status, printed = 0;
Tcl_DString list;
Tcl_DStringInit(&list);
status = LLDnodePtr2First(handle);
while (status == 1) {
LLDnodeDataTo(handle, &entry);
snprintf(pBueffel, 131, "%8.3f %10s %8.3f %d %8.3f\n",
entry.twoThetaEnd, entry.scanVar, entry.step, entry.np,
entry.preset);
Tcl_DStringAppend(&list, pBueffel, -1);
printed = 1;
status = LLDnodePtr2Next(handle);
}
if (printed == 0) {
Tcl_DStringAppend(&list, "table is empty", -1);
}
SCWrite(pCon, Tcl_DStringValue(&list), eValue);
Tcl_DStringFree(&list);
}
/*--------------------------------------------------------------------- /*---------------------------------------------------------------------
Make sure that the entry is added in a sorted way according to two_theta Make sure that the entry is added in a sorted way according to two_theta
----------------------------------------------------------------------*/ ----------------------------------------------------------------------*/
static void insertEntry(int list, FourTableEntry newEntry) static int rowCompare(const void *r1, const void *r2)
{ {
int status, count = 0, pos; pHdb *row1, *row2;
FourTableEntry test; pHdb tth1, tth2;
/* row1 = (pHdb *)r1;
locate the last entry bigger then us row2 = (pHdb *)r2;
*/ tth1 = GetHipadabaNode(*row1,"endTTH");
status = LLDnodePtr2First(list); tth2 = GetHipadabaNode(*row2,"endTTH");
while (status == 1) { assert(tth1 != NULL && tth2 != NULL);
LLDnodeDataTo(list, &test); if(tth1->value.v.doubleValue < tth2->value.v.doubleValue){
count++; return -1;
if (test.twoThetaEnd == newEntry.twoThetaEnd) { } else if(tth1->value.v.doubleValue > tth2->value.v.doubleValue){
LLDnodeDataFrom(list, &newEntry); return 1;
return; } else {
} return 0;
if (test.twoThetaEnd > newEntry.twoThetaEnd) { }
break;
}
status = LLDnodePtr2Next(list);
}
/*
special case: empty list
*/
if (count == 0) {
LLDnodeAppendFrom(list, &newEntry);
return;
}
/*
special case: append after last
*/
LLDnodePtr2Last(list);
LLDnodeDataTo(list, &test);
if (newEntry.twoThetaEnd > test.twoThetaEnd) {
LLDnodeAppendFrom(list, &newEntry);
return;
}
status = LLDnodePtr2First(list);
pos = 0;
while (status == 1) {
LLDnodeDataTo(list, &test);
pos++;
if (pos == count) {
LLDnodeInsertFrom(list, &newEntry);
return;
}
status = LLDnodePtr2Next(list);
}
} }
/*--------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*/ static void sortFourTable(pSICSOBJ self)
static int addToList(int handle, SConnection * pCon, int argc,
char *argv[])
{ {
FourTableEntry entry; pHdb data, *dataArray, child;
char pBueffel[132]; int count, i;
char number[10];
if (argc < 7) {
SCWrite(pCon, "ERROR: not enough arguments to table add", eError); data = GetHipadabaNode(self->objectNode,"data");
return 0; assert(data != NULL);
} count = CountHdbChildren(data);
if(count <= 1){
if (isNumeric(argv[3])) { return;
entry.twoThetaEnd = atof(argv[3]); }
} else {
snprintf(pBueffel, 131, dataArray = malloc(count*sizeof(pHdb));
"ERROR: expected numeric argument, received %s", argv[3]); if(dataArray == NULL){
SCWrite(pCon, pBueffel, eError); return;
return 0; }
} child = data->child;
strncpy(entry.scanVar, argv[4], 29); count = 0;
strtolower(entry.scanVar); while(child != NULL){
if (strcmp(entry.scanVar, "om") != 0 dataArray[count] = child;
&& strstr(entry.scanVar, "o2t") == NULL) { count++;
SCWrite(pCon, child = child->next;
"ERROR: Invalied scan variable specified, only om, o2t allowed", }
eError);
return 0; qsort(dataArray, count, sizeof(pHdb), rowCompare);
}
if (isNumeric(argv[5])) { data->child = NULL;
entry.step = atof(argv[5]); for(i = 0; i < count; i++){
} else { snprintf(number,10,"%4.4d", i);
snprintf(pBueffel, 131, child = dataArray[i];
"ERROR: expected numeric argument, received %s", argv[4]); if(child->name != NULL){
SCWrite(pCon, pBueffel, eError); free(child->name);
return 0; }
} child->name = strdup(number);
if (isNumeric(argv[6])) { AddHipadabaChild(data,child, NULL);
entry.np = atoi(argv[6]); }
} else { free(dataArray);
snprintf(pBueffel, 131,
"ERROR: expected numeric argument, received %s", argv[6]);
SCWrite(pCon, pBueffel, eError);
return 0;
}
entry.preset = -1.0;
if (argc > 7) {
if (isNumeric(argv[7])) {
entry.preset = atof(argv[7]);
}
}
insertEntry(handle, entry);
return 1;
} }
/*-----------------------------------------------------------------------*/
static void delEntry(int handle, int index)
{
int count = 0, status;
status = LLDnodePtr2First(handle);
while (status == 1) {
if (count == index) {
LLDnodeDelete(handle);
break;
} else {
count++;
status = LLDnodePtr2Next(handle);
}
}
}
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
int HandleFourCircleCommands(int *table, SConnection * pCon, int HandleFourCircleCommands(pSICSOBJ self, SConnection * pCon,
int argc, char *argv[], int *err) int argc, char *argv[], int *err)
{ {
int handle; int status;
*err = 1;
handle = *table;
/* /*
test if this is for us test if this is for us
*/ */
@ -208,141 +117,84 @@ int HandleFourCircleCommands(int *table, SConnection * pCon,
return 0; return 0;
} }
/* status = InvokeSICSOBJ(pCon,pServ->pSics,self,argc-1,&argv[1]);
what are we supposed to do? if(strcmp(argv[2],"addrow") == 0){
*/ sortFourTable(self);
strtolower(argv[2]);
if (strcmp(argv[2], "clear") == 0) {
if (!SCMatchRights(pCon, usUser)) {
*err = 0;
return 1;
}
LLDdelete(handle);
handle = LLDcreate(sizeof(FourTableEntry));
*table = handle;
SCparChange(pCon);
SCSendOK(pCon);
} else if (strcmp(argv[2], "list") == 0) {
printList(handle, pCon);
} else if (strcmp(argv[2], "add") == 0) {
if (!SCMatchRights(pCon, usUser)) {
*err = 0;
return 1;
}
*err = addToList(handle, pCon, argc, argv);
if (*err != 0) {
SCparChange(pCon);
SCSendOK(pCon);
}
} else if (strcmp(argv[2], "del") == 0) {
if (!SCMatchRights(pCon, usUser)) {
*err = 0;
return 1;
}
if (argc < 4) {
SCWrite(pCon, "ERROR: insufficnet number of arguments to table del",
eError);
*err = 0;
} else {
if (isNumeric(argv[3])) {
delEntry(handle, atoi(argv[3]));
SCparChange(pCon);
SCSendOK(pCon);
} else {
SCWrite(pCon,
"ERROR: bad argument: expected numeric argument to table del",
eError);
*err = 0;
}
}
} else {
SCWrite(pCon, "ERROR: subcommand to table not known", eError);
*err = 0;
} }
return status;
return 1;
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static FourTableEntry findEntry(int handle, double two_theta) static pHdb findEntry(pSICSOBJ self, double two_theta)
{ {
int status; pHdb data, row, tth;
FourTableEntry entry;
data = GetHipadabaNode(self->objectNode,"data");
status = LLDnodePtr2First(handle); assert(data != NULL);
while (status == 1) { row = data->child;
LLDnodeDataTo(handle, &entry); while(row != NULL){
if (entry.twoThetaEnd > two_theta) { tth = GetHipadabaNode(row,"endTTH");
return entry; if(tth != NULL){
} if(tth->value.v.doubleValue > two_theta){
status = LLDnodePtr2Next(handle); return row;
} }
strcpy(entry.scanVar, "NOT FOUND"); }
return entry; row = row->next;
}
return NULL;
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
char *GetFourCircleScanVar(int handle, double two_theta) char *GetFourCircleScanVar(pSICSOBJ handle, double two_theta)
{ {
FourTableEntry entry; pHdb row, val;
entry = findEntry(handle, two_theta); row = findEntry(handle, two_theta);
return strdup(entry.scanVar); if(row != NULL){
} val = GetHipadabaNode(row,"scanvar");
if(val != NULL){
/*------------------------------------------------------------------------*/ return strdup(val->value.v.text);
double GetFourCircleStep(int handle, double two_theta) }
{
FourTableEntry entry;
entry = findEntry(handle, two_theta);
if (strcmp(entry.scanVar, "NOT FOUND") == 0) {
return -999.99;
} else {
return entry.step;
} }
return strdup("Not found");
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
float GetFourCirclePreset(int handle, double two_theta) double GetFourCircleStep(pSICSOBJ handle, double two_theta)
{ {
FourTableEntry entry; pHdb row, val;
entry = findEntry(handle, two_theta); row = findEntry(handle, two_theta);
if (strcmp(entry.scanVar, "NOT FOUND") == 0) { if(row != NULL){
return -999.99; val = GetHipadabaNode(row,"step");
} else { if(val != NULL){
return entry.preset; return val->value.v.doubleValue;
} }
}
return -999.99;
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
int GetFourCircleScanNP(int handle, double two_theta) float GetFourCirclePreset(pSICSOBJ handle, double two_theta)
{ {
FourTableEntry entry; pHdb row, val;
entry = findEntry(handle, two_theta); row = findEntry(handle, two_theta);
if (strcmp(entry.scanVar, "NOT FOUND") == 0) { if(row != NULL){
return -999; val = GetHipadabaNode(row,"preset");
} else { if(val != NULL){
return entry.np; return val->value.v.doubleValue;
} }
}
return -999.99;
} }
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
int SaveFourCircleTable(int handle, char *objName, FILE * fd) int GetFourCircleScanNP(pSICSOBJ handle, double two_theta)
{ {
FourTableEntry entry; pHdb row, val;
int status;
row = findEntry(handle, two_theta);
fprintf(fd, "%s table clear\n", objName); if(row != NULL){
status = LLDnodePtr2Last(handle); val = GetHipadabaNode(row,"np");
while (status != 0) { if(val != NULL){
LLDnodeDataTo(handle, &entry); return val->value.v.intValue;
fprintf(fd, "%s table add %f %s %f %d %f\n", objName, }
entry.twoThetaEnd, entry.scanVar, }
entry.step, entry.np, entry.preset); return 1;
status = LLDnodePtr2Prev(handle);
}
return 1;
} }

16
fourtable.h
View File

@ -10,15 +10,15 @@
---------------------------------------------------------------------------*/ ---------------------------------------------------------------------------*/
#ifndef FOURTABLE #ifndef FOURTABLE
#define FOURTABLE #define FOURTABLE
#include <sicsobj.h>
int MakeFourCircleTable(); pSICSOBJ MakeFourCircleTable();
void DeleteFourCircleTable(int handle); void DeleteFourCircleTable(pSICSOBJ self);
int HandleFourCircleCommands(int *handle, SConnection * pCon, int HandleFourCircleCommands(pSICSOBJ self, SConnection * pCon,
int argc, char *argv[], int *err); int argc, char *argv[], int *err);
char *GetFourCircleScanVar(int handle, double two_theta); char *GetFourCircleScanVar(pSICSOBJ self, double two_theta);
double GetFourCircleStep(int handle, double two_theta); double GetFourCircleStep(pSICSOBJ self, double two_theta);
int SaveFourCircleTable(int handle, char *objName, FILE * fd); float GetFourCirclePreset(pSICSOBJ self, double twoTheta);
float GetFourCirclePreset(int handle, double twoTheta); int GetFourCircleScanNP(pSICSOBJ self, double twoTheta);
int GetFourCircleScanNP(int handle, double twoTheta);
#endif #endif

381
hdbtable.c Normal file
View File

@ -0,0 +1,381 @@
/**
* Hdbtable is a more generic implementation for a table based on a Hipadaba
* tree structure. This table will be used at various instances in SICS. The general
* approach is that there is a child node called template whose children will be
* the nodes describing each column. Another entry called data will hold the
* rows of the table. Each row is a clone of the template. The result is
* an inefficient mapping of a table into a tree. But then, for smaller tables this
* is good enough and fits nicely into the Hipadaba and gumtree schemes. This file
* provides a couple of commands to deal with such tables. A user of this module will
* have to add content to the template first. And then run readtemplate in order
* to activate the new structure.
*
* I use a descriptor key called rowcount for the row ID management rather then
* the private data structure. This leaves clients of this module to use the
* private data structure at will.
*
* copyright: see file COPYRIGHT
*
* Mark Koennecke, March 2009
*/
#include <stdlib.h>
#include "sicshipadaba.h"
#include <hdbtable.h>
/*------------------------------------------------------------------------*/
int SaveHdbTable(void *data, char *name, FILE * fd)
{
pSICSOBJ self = (pSICSOBJ) data;
pHdb datanode, row, child;
pDynString val;
datanode = GetHipadabaNode(self->objectNode,"data");
assert(datanode != NULL);
row = datanode->child;
while(row != NULL){
fprintf(fd,"%s addrow ", name);
child = row->child;
while(child != NULL){
val = formatValue(child->value, child);
if(val != NULL){
fprintf(fd," %s", GetCharArray(val));
DeleteDynString(val);
}
child = child->next;
}
fprintf(fd,"\n");
row = row->next;
}
return 1;
}
/*------------------------------------------------------------------------*/
static int ClearTblCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
pHdb node;
node = GetHipadabaNode(self->objectNode,"data");
if(node != NULL){
DeleteNodeData(node);
RemoveHdbNodeFromParent(node, pCon);
}
node = MakeHipadabaNode("data",HIPNONE,1);
if(node == NULL){
SCWrite(pCon,"ERROR: out of memory in ClearTblCmd", eError);
return 0;
}
AddHipadabaChild(self->objectNode,node,NULL);
SetDescriptorKey(self->pDes,"rowcount","0");
if(pCon != NULL){
SCparChange(pCon);
}
return 1;
}
/*----------------------------------------------------------------------*/
static int AddTblRowCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
int count;
char *ct, number[10];
pHdb row, val, child, template;
ct = GetDescriptorKey(self->pDes,"rowcount");
count = atoi(ct);
snprintf(number,10,"%4.4d", count);
row = MakeHipadabaNode(number,HIPNONE,1);
if(row == NULL){
SCWrite(pCon,"ERROR: out of memory in AddTblRow", eError);
return 0;
}
count++;
snprintf(number,10,"%d",count);
SetDescriptorKey(self->pDes,"rowcount",number);
SetHdbProperty(row,"__save","true");
template = GetHipadabaNode(self->objectNode,"template");
assert(template != NULL);
child = template->child;
count = 0;
while(child != NULL){
val = MakeHipadabaNode(child->name,child->value.dataType, child->value.arrayLength);
if(count < nPar){
UpdateHipadabaPar(val,par[count]->value,pCon);
}
AddHipadabaChild(row,val, pCon);
SetHdbProperty(val,"__save","true");
count++;
child = child->next;
}
child = GetHipadabaNode(self->objectNode,"data");
assert(child != NULL);
AddHipadabaChild(child,row, pCon);
if(pCon != NULL){
SCparChange(pCon);
}
return 1;
}
/*----------------------------------------------------------------------*/
static int RepTblRowCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
int count;
char path[132];
pHdb row, val, child;
snprintf(path,131,"data/%s", par[0]->value.v.text);
row = GetHipadabaNode(self->objectNode,path);
if(row == NULL){
SCPrintf(pCon,eError,"ERROR: row with ID %s not found", par[0]->value.v.text);
return 0;
}
child = row->child;
count = 1;
while(child != NULL){
if(count < nPar){
UpdateHipadabaPar(child,par[count]->value,pCon);
}
count++;
child = child->next;
}
if(pCon != NULL){
SCparChange(pCon);
}
return 1;
}
/*----------------------------------------------------------------------
* ReadTemplateCmd does something interesting: it rewrites the parameter
* lists of both addrow and reprow according to the template
* ---------------------------------------------------------------------*/
int ReadTableTemplate(pSICSOBJ self, SConnection *con)
{
pHdb node, template, child, cmd;
SConnection *pCon = con;
if(pCon == NULL){
pCon = pServ->dummyCon;
}
template = GetHipadabaNode(self->objectNode,"template");
assert(template != NULL);
node = GetHipadabaNode(self->objectNode,"addrow");
if(node != NULL){
DeleteHipadabaNode(node,pCon);
}
cmd = AddSICSHdbPar(self->objectNode, "addrow", usUser,
MakeSICSFunc(AddTblRowCmd));
if(cmd == NULL){
SCWrite(pCon,"ERROR: out of memory in ReadTemplateCmd",eError );
return 0;
}
child = template->child;
while(child != NULL){
node = MakeHipadabaNode(child->name, child->value.dataType, child->value.arrayLength);
if(node == NULL){
SCWrite(pCon,"ERROR: out of memory in ReadTemplateCmd",eError );
return 0;
}
AddHipadabaChild(cmd,node,pCon);
child = child->next;
}
cmd = AddSICSHdbPar(self->objectNode, "reprow", usUser,
MakeSICSFunc(AddTblRowCmd));
if(cmd == NULL){
SCWrite(pCon,"ERROR: out of memory in ReadTemplateCmd",eError );
return 0;
}
node = MakeHipadabaNode("id",HIPTEXT,1);
AddHipadabaChild(cmd,node, pCon);
child = template->child;
while(child != NULL){
node = MakeHipadabaNode(child->name, child->value.dataType, child->value.arrayLength);
if(node == NULL){
SCWrite(pCon,"ERROR: out of memory in ReadTemplateCmd",eError );
return 0;
}
AddHipadabaChild(cmd,node,pCon);
child = child->next;
}
return 1;
}
/*----------------------------------------------------------------------*/
static int ReadTemplateCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
return ReadTableTemplate(self,pCon);
}
/*----------------------------------------------------------------------*/
static int DelRowCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
pHdb row = NULL;
char path[132];
if(nPar < 1){
SCWrite(pCon,"ERROR: need ID of row to kill",eError);
return 0;
}
snprintf(path,132,"data/%s",par[0]->value.v.text);
row = GetHipadabaNode(self->objectNode,path);
if(row == NULL){
SCPrintf(pCon,eError,"ERROR: row with ID %s not found", par[0]->value.v.text);
return 0;
}
DeleteHipadabaNode(row,pCon);
if(pCon != NULL){
SCparChange(pCon);
}
SCSendOK(pCon);
return 1;
}
/*----------------------------------------------------------------------*/
static int GetRowCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
pHdb row = NULL, child;
char path[132];
pDynString result, val;
if(nPar < 1){
SCWrite(pCon,"ERROR: need ID of row to read",eError);
return 0;
}
snprintf(path,132,"data/%s",par[0]->value.v.text);
row = GetHipadabaNode(self->objectNode,path);
if(row == NULL){
SCPrintf(pCon,eError,"ERROR: row with ID %s not found", par[0]->value.v.text);
return 0;
}
result = CreateDynString(128,128);
if(result == NULL){
SCWrite(pCon,"ERROR: out of memory in GetRowCmd", eError);
return 0;
}
child = row->child;
while(child != NULL){
val = formatValue(child->value, child);
if(val != NULL){
DynStringConcat(result,GetCharArray(val));
if(child->next != NULL){
DynStringConcatChar(result,',');
}
DeleteDynString(val);
}
child = child->next;
}
SCWrite(pCon,GetCharArray(result),eValue);
DeleteDynString(result);
return 1;
}
/*----------------------------------------------------------------------*/
static int ListTblCmd(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
pHdb par[], int nPar)
{
pHdb node, row, child, data, template;
char buffer[20];
pDynString list = NULL, val;
list = CreateDynString(25,256);
if(list == NULL){
SCWrite(pCon,"ERROR: out of memory in LisTblCmd", eError);
return 0;
}
/*
* create the list header
*/
DynStringConcat(list," ID");
template = GetHipadabaNode(self->objectNode,"template");
assert(template != NULL);
child = template->child;
while(child != NULL){
snprintf(buffer,20," %8s", child->name);
DynStringConcat(list,buffer);
child = child->next;
}
DynStringConcatChar(list,'\n');
data = GetHipadabaNode(self->objectNode,"data");
assert(data != NULL);
/*
* list the data
*/
row = data->child;
while(row != NULL){
snprintf(buffer,20," %8s", row->name);
DynStringConcat(list,buffer);
child = row->child;
while(child != NULL){
val = formatValue(child->value,child);
snprintf(buffer,20," %8s", GetCharArray(val));
DynStringConcat(list,buffer);
DeleteDynString(val);
child = child->next;
}
DynStringConcatChar(list,'\n');
row = row->next;
}
SCWrite(pCon,GetCharArray(list),eValue);
DeleteDynString(list);
return 1;
}
/*----------------------------------------------------------------------*/
pSICSOBJ MakeHdbTable(char *name, char *hdbclass)
{
pSICSOBJ result = NULL;
pHdb node, cmd;
result = MakeSICSOBJv(name,hdbclass,HIPNONE,usSpy);
if(result == NULL){
return NULL;
}
SetDescriptorKey(result->pDes,"rowcount","0");
SetHdbProperty(result->objectNode,"viewer","mountaingumui.TableViewer");
result->pDes->SaveStatus = SaveHdbTable;
node = MakeHipadabaNode("template",HIPNONE,1);
if(node == NULL){
return NULL;
}
SetHdbProperty(node,"__save","true");
AddHipadabaChild(result->objectNode,node,NULL);
node = MakeHipadabaNode("data",HIPNONE,1);
if(node == NULL){
return NULL;
}
SetHdbProperty(node,"__save","true");
AddHipadabaChild(result->objectNode,node,NULL);
cmd = AddSICSHdbPar(result->objectNode, "clear", usUser,
MakeSICSFunc(ClearTblCmd));
cmd = AddSICSHdbPar(result->objectNode, "print", usUser,
MakeSICSFunc(ListTblCmd));
cmd = AddSICSHdbPar(result->objectNode, "addrow", usUser,
MakeSICSFunc(AddTblRowCmd));
cmd = AddSICSHdbPar(result->objectNode, "reprow", usUser,
MakeSICSFunc(RepTblRowCmd));
cmd = AddSICSHdbPar(result->objectNode, "readtemplate", usUser,
MakeSICSFunc(ReadTemplateCmd));
cmd = AddSICSHdbPar(result->objectNode, "del", usUser,
MakeSICSFunc(DelRowCmd));
node = MakeHipadabaNode("id",HIPTEXT,1);
AddHipadabaChild(cmd,node, NULL);
cmd = AddSICSHdbPar(result->objectNode, "get", usUser,
MakeSICSFunc(GetRowCmd));
node = MakeHipadabaNode("id",HIPTEXT,1);
AddHipadabaChild(cmd,node, NULL);
return result;
}

16
hdbtable.h Normal file
View File

@ -0,0 +1,16 @@
/**
* Hdbtable is a more generic implementation for a table based on a Hipadaba
* tree structure. This table will be used at various instances in SICS.
*
* copyright: see file COPYRIGHT
*
* Mark Koennecke, March 2009
*/
#ifndef HDBTABLE_H_
#define HDBTABLE_H_
#include <sicsobj.h>
pSICSOBJ MakeHdbTable(char *name, char *hdbclass);
int ReadTableTemplate(pSICSOBJ self, SConnection *con);
#endif /*HDBTABLE_H_*/

2
hipadaba.c
View File

@ -202,7 +202,7 @@ int InvokeCallbackChain(pHdb node, pHdbMessage message)
} }
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static void SendTreeChangeMessage(pHdb node, void *callData) void SendTreeChangeMessage(pHdb node, void *callData)
{ {
hdbTreeChangeMessage treeChangeMes; hdbTreeChangeMessage treeChangeMes;
treeChangeMes.type = treeChange; treeChangeMes.type = treeChange;

7
hipadaba.h
View File

@ -274,6 +274,13 @@ void AddHipadabaChild(pHdb parent, pHdb child, void *callData);
* @param node The node to delete. * @param node The node to delete.
*/ */
void DeleteNodeData(pHdb node); void DeleteNodeData(pHdb node);
/**
* Send a treechange message for node.
* @param node The node whose child list has changed
* @param calldata The connection or calldata associated with this operation.
*/
void SendTreeChangeMessage(pHdb node, void *callData);
/** /**
* delete a hipadaba node and all its children. Then invoke the tree * delete a hipadaba node and all its children. Then invoke the tree
* change callback to notify listeners. * change callback to notify listeners.

63
histmem.c
View File

@ -12,6 +12,11 @@
Refactored data handling into separater HMdata class. Refactored data handling into separater HMdata class.
Mark Koennecke, January 2003 Mark Koennecke, January 2003
Added function to retrieve time delay and to format TOF bin array in order
to speed up TOF configuration for new http based HM's
Mark Koennecke, March 2009
Copyright: Copyright:
@ -1034,7 +1039,40 @@ void HMListOption(pHistMem self, SConnection * pCon)
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static pDynString formatTOF(pHistMem self)
{
const float *timebin;
int iLength, i, delay, delta;
char number[20];
pDynString result = NULL;
timebin = GetHistTimeBin(self, &iLength);
if(timebin != NULL){
delay = timebin[0];
result = CreateDynString(512,512);
if(result == NULL){
return NULL;
}
for(i = 0; i < iLength; i++){
snprintf(number,20," %12d", (int)(timebin[i] - delay));
DynStringConcat(result,number);
if(i % 5 == 0 && i != 0){
DynStringConcatChar(result,'\n');
}
}
/*
* add the extra one
*/
if(iLength > 3){
delta = timebin[iLength -2] - timebin[iLength -1];
}
snprintf(number,20," %12d", (int)(timebin[iLength -1] + delta));
DynStringConcat(result,number);
return result;
} else {
return NULL;
}
}
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
int HistAction(SConnection * pCon, SicsInterp * pSics, void *pData, int HistAction(SConnection * pCon, SicsInterp * pSics, void *pData,
int argc, char *argv[]) int argc, char *argv[])
@ -1049,6 +1087,7 @@ int HistAction(SConnection * pCon, SicsInterp * pSics, void *pData,
long lVal; long lVal;
HistInt *lData = NULL; HistInt *lData = NULL;
int iStart, iEnd, iNum, i; int iStart, iEnd, iNum, i;
pDynString tofres = NULL;
CounterMode eCount; CounterMode eCount;
char *pMode[] = { char *pMode[] = {
"timer", "timer",
@ -1527,6 +1566,28 @@ int HistAction(SConnection * pCon, SicsInterp * pSics, void *pData,
Tcl_DStringFree(&tResult); Tcl_DStringFree(&tResult);
return 1; return 1;
} }
/* getdelay */
else if(strcmp(argv[1],"getdelay") == 0){
if(self->pDriv->data->nTimeChan > 1) {
SCPrintf(pCon,eValue,"hm.delay = %d", self->pDriv->data->timeBinning[0]);
return 1;
} else {
SCPrintf(pCon,eError,"ERROR: no TOF configured");
return 0;
}
}
/* formattof */
else if(strcmp(argv[1],"formattof") == 0){
tofres = formatTOF(self);
if(tofres == NULL){
SCWrite(pCon,"ERROR: out of memory or not TOF", eError);
return 0;
} else {
SCWrite(pCon,GetCharArray(tofres), eValue);
DeleteDynString(tofres);
return 1;
}
}
/* generate time binning */ /* generate time binning */
else if (strcmp(argv[1], "genbin") == 0) { else if (strcmp(argv[1], "genbin") == 0) {
if (isRunning(self->pCountInt)) { if (isRunning(self->pCountInt)) {

4
make_gen
View File

@ -18,7 +18,7 @@ SOBJ = network.o ifile.o conman.o SCinter.o splitter.o passwd.o \
danu.o nxdict.o varlog.o stptok.o nread.o trigd.o cell.o\ danu.o nxdict.o varlog.o stptok.o nread.o trigd.o cell.o\
scan.o fitcenter.o telnet.o token.o wwildcard.o hklmot.o\ scan.o fitcenter.o telnet.o token.o wwildcard.o hklmot.o\
tclev.o hkl.o integrate.o optimise.o dynstring.o nxutil.o \ tclev.o hkl.o integrate.o optimise.o dynstring.o nxutil.o \
mesure.o uubuffer.o commandlog.o udpquieck.o fourtable.o\ uubuffer.o commandlog.o udpquieck.o fourtable.o\
rmtrail.o help.o nxupdate.o confvirtualmot.o vector.o\ rmtrail.o help.o nxupdate.o confvirtualmot.o vector.o\
simchop.o choco.o chadapter.o trim.o scaldate.o tasub.o\ simchop.o choco.o chadapter.o trim.o scaldate.o tasub.o\
xytable.o exebuf.o exeman.o ubfour.o ubcalc.o\ xytable.o exebuf.o exeman.o ubfour.o ubcalc.o\
@ -40,7 +40,7 @@ SOBJ = network.o ifile.o conman.o SCinter.o splitter.o passwd.o \
sctdriveadapter.o sctdriveobj.o reflist.o singlex.o fourmess.o \ sctdriveadapter.o sctdriveobj.o reflist.o singlex.o fourmess.o \
sgclib.o sgfind.o sgio.o sgsi.o sghkl.o singlediff.o singlebi.o \ sgclib.o sgfind.o sgio.o sgsi.o sghkl.o singlediff.o singlebi.o \
singlenb.o simindex.o simidx.o uselect.o singletas.o motorsec.o \ singlenb.o simindex.o simidx.o uselect.o singletas.o motorsec.o \
rwpuffer.o asynnet.o background.o countersec.o rwpuffer.o asynnet.o background.o countersec.o hdbtable.o
MOTOROBJ = motor.o simdriv.o MOTOROBJ = motor.o simdriv.o
COUNTEROBJ = countdriv.o simcter.o counter.o COUNTEROBJ = countdriv.o simcter.o counter.o

1692
mesure.c
View File

File diff suppressed because it is too large Load Diff

45
mesure.h
View File

@ -1,45 +0,0 @@
/*----------------------------------------------------------------------------
M E S U R E
A SICS object for doing four circle measurements with a single
counter.
copyright: see copyright.h
Mark Koennecke, April 1998
Heavily reworked: Mark Koennecke, February-March 2005
---------------------------------------------------------------------------*/
#ifndef SICSMESURE
#define SICSMESURE
typedef struct __Mesure *pMesure;
/*--------------------- live & death --------------------------------------*/
pMesure CreateMesure(pHKL pCryst, pScanData pScanner,
pMotor pOmega, char *pom,
pMotor p2Theta, char *p2t,
char *pFileRoot, pDataNumber pDanu,
char *headerTemplate);
void DeleteMesure(void *pData);
int MesureFactory(SConnection * pCon, SicsInterp * pSics, void *pData,
int argc, char *argv[]);
/*------------------- object functions -----------------------------------*/
int MesureReflection(pMesure self, float fHKL[3], float fPsi,
SConnection * pCon);
int MesureGenReflection(pMesure self, float fHKL[3], float fSet[4],
SConnection * pCon);
int MesureStart(pMesure self, SConnection * pCon);
int MesureReopen(pMesure self, char *filename, SConnection * pCon);
int MesureClose(pMesure self);
int MesureFile(pMesure self, char *pFile, int iSkip, SConnection * pCon);
int MesureGenFile(pMesure self, char *pFile, int iSkip,
SConnection * pCon);
int MesureSetPar(pMesure self, char *name, float fVal);
int MesureGetPar(pMesure self, char *name, float *fVal);
int MesureAction(SConnection * pCon, SicsInterp * pSics, void *pData,
int argc, char *argv[]);
#endif

2
ofac.c
View File

@ -80,7 +80,6 @@
#include "token.h" #include "token.h"
#include "hkl.h" #include "hkl.h"
#include "optimise.h" #include "optimise.h"
#include "mesure.h"
#include "commandlog.h" #include "commandlog.h"
#include "udpquieck.h" #include "udpquieck.h"
#include "choco.h" #include "choco.h"
@ -291,7 +290,6 @@ static void InitIniCommands(SicsInterp * pInter, pTaskMan pTask)
AddCommand(pInter, "MakePeakCenter", FitFactory, NULL, NULL); AddCommand(pInter, "MakePeakCenter", FitFactory, NULL, NULL);
AddCommand(pInter, "MakeHKL", HKLFactory, NULL, NULL); AddCommand(pInter, "MakeHKL", HKLFactory, NULL, NULL);
AddCommand(pInter, "MakeOptimise", MakeOptimiser, NULL, NULL); AddCommand(pInter, "MakeOptimise", MakeOptimiser, NULL, NULL);
AddCommand(pInter, "MakeMesure", MesureFactory, NULL, NULL);
AddCommand(pInter, "kill_command", SICSKill, NULL, NULL); AddCommand(pInter, "kill_command", SICSKill, NULL, NULL);
AddCommand(pInter, "MakeChopper", ChocoFactory, NULL, NULL); AddCommand(pInter, "MakeChopper", ChocoFactory, NULL, NULL);
AddCommand(pInter, "ChopperAdapter", CHAdapterFactory, NULL, NULL); AddCommand(pInter, "ChopperAdapter", CHAdapterFactory, NULL, NULL);

765
reflist.c
View File

File diff suppressed because it is too large Load Diff

24
sicsobj.c
View File

@ -6,6 +6,7 @@
* Mark Koennecke, July 2007 * Mark Koennecke, July 2007
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdarg.h>
#include <sics.h> #include <sics.h>
#include <tcl.h> #include <tcl.h>
#include "assert.h" #include "assert.h"
@ -186,7 +187,26 @@ static int assignPar(pHdb node, SConnection * pCon, char *data)
} }
return 1; return 1;
} }
/*---------------------------------------------------------------------------*/
int runObjFunction(pSICSOBJ object, SConnection *pCon, pHdb commandNode)
{
pHdb parArray[64], child;
int status, count = 0;
SICSOBJFunc pFunc = NULL;
assert(commandNode != NULL);
child = commandNode->child;
while(child != NULL){
parArray[count] = child;
count++;
child = child->next;
}
pFunc = (SICSOBJFunc)commandNode->value.v.func;
assert(pFunc != NULL);
status = pFunc(object, pCon, commandNode, parArray, count);
return status;
}
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static int invokeOBJFunction(pSICSOBJ object, pHdb commandNode, static int invokeOBJFunction(pSICSOBJ object, pHdb commandNode,
SConnection * pCon, int argc, char *argv[]) SConnection * pCon, int argc, char *argv[])
@ -210,7 +230,7 @@ static int invokeOBJFunction(pSICSOBJ object, pHdb commandNode,
count = 1; count = 1;
goto invoke; goto invoke;
} }
/* /*
* assign parameters and fill parameter array for function at the same * assign parameters and fill parameter array for function at the same
* time. Be lenient about missing parameters: Then the old values will * time. Be lenient about missing parameters: Then the old values will

11
sicsobj.h
View File

@ -9,6 +9,7 @@
#define SICSOBJ2_H_ #define SICSOBJ2_H_
#include <stdio.h> #include <stdio.h>
#include <hipadaba.h> #include <hipadaba.h>
#include "sics.h"
/*====================================================================== /*======================================================================
* Be careful when changing this data structure. It has to be compatible * Be careful when changing this data structure. It has to be compatible
* in its first fields with the SICS object descriptor as defined in * in its first fields with the SICS object descriptor as defined in
@ -43,6 +44,16 @@ int SaveSICSOBJ(void *data, char *name, FILE * fd);
*/ */
pSICSOBJ SetupSICSOBJ(SConnection * pCon, SicsInterp * pSics, void *pData, pSICSOBJ SetupSICSOBJ(SConnection * pCon, SicsInterp * pSics, void *pData,
int argc, char *argv[]); int argc, char *argv[]);
/**
* runObjectFunction is an internal function for running an existing object
* command. The user has to search the node first, prime the parameters,
* and then call this command to actually execute.
* @param object The object on which the command is executed
* @param pCon a connection to use for error reporting
* @param commandNode The node to invoke.
*/
int runObjFunction(pSICSOBJ object, SConnection *pCon, pHdb commandNode);
/*====================== Interpreter Interface =========================== /*====================== Interpreter Interface ===========================
* InvokeSICSObj is special in that it returns -1 if it cannot handle * InvokeSICSObj is special in that it returns -1 if it cannot handle
* the command. This leaves calling code the opportunity to process * the command. This leaves calling code the opportunity to process