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

- Poldi data file writing with automatic update

Browse Source 
- many fixes to TAS
- Changed HM code for ILL PSD to account for Christoph's offset to
  positive.
This commit is contained in:
cvs
2002-04-25 09:39:51 +00:00
parent 0ce72deb58
commit 0daef05b2e
19 changed files with 604 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
HistDriv.i
View File

@ -10,7 +10,7 @@
----------------------------------------------------------------------------*/
#ifndef SICSHISTDRIV
#define SICSHISTDRIV
#define MAXCHAN 4096
#define MAXCHAN 16834
#line 82 "histogram.w"

4
amortest.tcl
View File

@ -185,8 +185,8 @@ Motor COX SIM -100. 100. .1 2. # counter x
ClientPut "Motors initialized"
#======================== histogram memory
MakeHM hm SinqHM
#MakeHM hm SIM
#MakeHM hm SinqHM
MakeHM hm SIM
hm configure HistMode PSD
hm configure OverFlowMode Ceil
hm configure Rank 1

2
danu.dat
View File

@ -1,3 +1,3 @@
189
212
NEVER, EVER modify or delete this file
You'll risk eternal damnation and a reincarnation as a cockroach!|n

1
histmem.c
View File

@ -62,7 +62,6 @@
#include "dynstring.h"
#include "event.h"
#include "status.h"
/*
#define LOADDEBUG 1
*/

2
histogram.tex
View File

@ -629,7 +629,7 @@ following.
\mbox{}\verb@----------------------------------------------------------------------------*/@\\
\mbox{}\verb@#ifndef SICSHISTDRIV@\\
\mbox{}\verb@#define SICSHISTDRIV@\\
\mbox{}\verb@#define MAXCHAN 4096@\\
\mbox{}\verb@#define MAXCHAN 16834 @\\
\mbox{}\verb@@\\
\mbox{}\verb@@$\langle$HistType {\footnotesize ?}$\rangle$\verb@@\\
\mbox{}\verb@@$\langle$HistDrivProt {\footnotesize ?}$\rangle$\verb@@\\

2
histogram.w
View File

@ -484,7 +484,7 @@ following.
----------------------------------------------------------------------------*/
#ifndef SICSHISTDRIV
#define SICSHISTDRIV
#define MAXCHAN 4096
#define MAXCHAN 16834
@< HistType@>
@< HistDrivProt @>

5
nextrics.c
View File

@ -33,6 +33,7 @@
#include "udpquieck.h"
#include "nextrics.h"
#define DET1X 256 /* x -length of detector 1 */
#define DET1Y 128 /* y-length of detector 1 */
#define DET1XS 2 /* pixel size in x of detector 1 */
@ -308,7 +309,7 @@ name of hkl object holding crystallographic information
CounterMode eMode;
HistInt lData[DET1X*DET1Y], i, lVal;
int32 iVal,lBeam;
float fVal, fTTheta;
float fVal, fTTheta, fTime = 0.;
pMotor pMot;
/* write motors */
@ -368,6 +369,7 @@ name of hkl object holding crystallographic information
eMode = GetCounterMode(self->pCount);
fVal = GetCounterPreset(self->pCount);
lVal = GetMonitor(self->pCount,1,pCon);
fTime = GetCountTime(self->pCount,pCon);
lBeam = GetMonitor(self->pCount,4,pCon);
}
if(eMode == eTimer)
@ -384,6 +386,7 @@ name of hkl object holding crystallographic information
NXDputalias(hfil,self->pDict,"framemonitor",&iVal);
iVal = (int32)lBeam;
NXDputalias(hfil,self->pDict,"sinqmonitor",&iVal);
NXDputalias(hfil,self->pDict,"cctime",&fTime);
/* write detector1 histogram */
if(self->pHistogram1 != NULL)

8
nxdata.c
View File

@ -347,7 +347,7 @@
void *pData)
{
int iStat;
int32 iDim[2];
int iDim[2];
iDim[0] = iLong;
iStat = NXmakedata (Nfil, name, datatype, 1, (int *) iDim);
@ -383,7 +383,7 @@
void *pData, char *attname, char *val)
{
int iStat;
int32 iDim[2];
int iDim[2];
iDim[0] = iLong;
iStat = NXmakedata (Nfil, name, datatype, 1, (int *) iDim);
@ -465,7 +465,7 @@
pSelVar pPell;
char *pP;
float fVal;
float32 *fTheta;
float *fTheta;
float fTh, f2Th, fB1, fB2;
pMotor pMot = NULL;
CommandList *pCom = NULL;
@ -474,7 +474,7 @@
pHistMem pHist = NULL;
HistInt *lData = NULL;
CounterMode eCount;
int32 *iTVal = NULL;
int *iTVal = NULL;
pDummy pDum;
int bHRPT = 0;
float fMean, fStdDev;

1
nxdict.c
View File

@ -34,7 +34,6 @@
#include <assert.h>
#include <string.h>
#include <time.h>
#include <mfhdf.h>
#include "lld.h"
#include "napi.h"
#include "stringdict.h"

1
nxsans.c
View File

@ -62,6 +62,7 @@
#include "mumo.h"
#include "sanswave.h"
#define HISTNAME "banana"
#define SAMPLETABLE "sampletable"

704
polterwrite.c
View File

@ -1,7 +1,7 @@
/*--------------------------------------------------------------------------
P O L T E R W R I T E
fowrite is an object for writing POLTERDI data files.
Polterwrite is an object for writing POLTI data files.
copyright: see copyright.h
@ -9,8 +9,12 @@
----------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include "fortify.h"
#include <math.h>
#include <time.h>
#include <tcl.h>
#undef VOID
#include "sics.h"
#include "event.h"
#include "counter.h"
#include "HistMem.h"
#include "nxdict.h"
@ -22,41 +26,68 @@
/*
diaphragm1 - chopper
*/
#define DIA1DIST 3000
/*
diaphragm2 - diaphragm1
*/
#define DIA2DIST 500
/*
diaphragm2 - sample position
*/
#define SADIST 500
#define DIA1DIST 8000
/*
histogram memory name
*/
#define HM "hm"
/*
detector distance - sample
*/
#define DETDIST 700
/*
no detectors, change in poldi.dic as well
*/
#define NODET 400
/*
theta spacing
*/
#define THSPACE .3
#define DETRADIUS 3000
typedef struct {
pObjectDescriptor pDes;
pHistMem pHist;
int iNew;
time_t tUpdate;
int iInterval;
int iEnd;
SConnection *pCon;
char *dictfile;
char *pFile;
}Polterdi, *pPolterdi;
/* ------------------- forward declaration of task function --------------*/
static int PoldiTask(void *pData);
static void PoldiUpdate(pPolterdi self, SConnection *pCon);
/*------------------ The Countstart Callback Function ----------------------*/
static int Countstartcallback(int iEvent, void *pEventData, void *pUser)
{
pPolterdi self = NULL;
if(iEvent == COUNTSTART)
{
self = (pPolterdi)pUser;
assert(self);
self->iNew = 1;
self->iEnd = 0;
self->tUpdate = time(NULL);
self->pCon = (SConnection *)pEventData;
TaskRegister(pServ->pTasker,PoldiTask,NULL,NULL,self,1);
return 1;
}
return 1;
}
/*------------------ The Countend Callback Function ----------------------*/
static int Countendcallback(int iEvent, void *pEventData, void *pUser)
{
pPolterdi self = NULL;
if(iEvent == COUNTEND)
{
self = (pPolterdi)pUser;
assert(self);
self->tUpdate = time(NULL);
self->iEnd = 1;
PoldiUpdate(self,self->pCon);
/*
Fortify_CheckAllMemory();
*/
return 1;
}
return 1;
}
/*----------------------------------------------------------------------*/
static void KillPolterdi(void *pData){
pPolterdi self = (pPolterdi)pData;
@ -66,6 +97,9 @@ static void KillPolterdi(void *pData){
if(self->pDes){
DeleteDescriptor(self->pDes);
}
if(self->pFile){
free(self->pFile);
}
if(self->dictfile){
free(self->dictfile);
}
@ -77,12 +111,26 @@ int PolterInstall(SConnection *pCon, SicsInterp *pSics,
void *pData, int argc, char *argv[])
{
pPolterdi pNew = NULL;
pICallBack pCall = NULL;
pDummy pDum;
pHistMem pHist = NULL;
/* configure fortify */
/*
iFortifyScope = Fortify_EnterScope();
Fortify_CheckAllMemory();
*/
if(argc < 2){
SCWrite(pCon,"ERROR: insufficient number of arguments to PolterInstall",
eError);
return 0;
}
pHist = (pHistMem)FindCommandData(pSics,HM,"HistMem");
if (!pHist)
{
}
pNew = (pPolterdi)malloc(sizeof(Polterdi));
if(!pNew){
@ -92,24 +140,42 @@ int PolterInstall(SConnection *pCon, SicsInterp *pSics,
}
memset(pNew,0,sizeof(Polterdi));
pNew->pDes = CreateDescriptor("PolterdiWrite");
pNew->pHist = pHist;
pNew->dictfile = strdup(argv[1]);
pNew->iInterval = 20*60;
if(!pNew->pDes || !pNew->dictfile){
SCWrite(pCon,"ERROR: out of memory in PolterInstall",
eError);
return 0;
}
return AddCommand(pSics,"storedata",PolterAction,KillPolterdi,pNew);
/* install callbacks */
pDum = (pDummy)pHist;
pCall = (pICallBack)pDum->pDescriptor->GetInterface(pHist,CALLBACKINTERFACE);
if(!pCall)
{
SCWrite(pCon,
"ERROR: no callback interface found at your histogram memory",
eError);
KillPolterdi(pNew);
return 0;
}
RegisterCallback(pCall,COUNTSTART,Countstartcallback,pNew,NULL);
RegisterCallback(pCall,COUNTEND,Countendcallback,pNew,NULL);
AddCommand(pSics,"storedata",PolterAction,KillPolterdi,pNew);
return 1;
}
/*-------------------------------------------------------------------*/
static void writePolterdiGlobal(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics){
static void writePolterdiGlobal(NXhandle hfil, NXdict hdict,
SConnection *pCon){
char pBueffel[512];
SNXSPutVariable(pSics,pCon,hfil,hdict,"etitle","title");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"etitle","title");
SNXFormatTime(pBueffel,511);
NXDputalias(hfil,hdict,"estart",pBueffel);
SNXSPutVariable(pSics,pCon,hfil,hdict,"iname","instrument");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"iname","instrument");
sprintf(pBueffel,"%d",strlen("SINQ, PSI, Switzerland"));
NXDupdate(hdict,"strdim",pBueffel);
NXDputalias(hfil,hdict,"sname","SINQ, PSI, Switzerland");
@ -119,95 +185,142 @@ static void writePolterdiGlobal(NXhandle hfil, NXdict hdict, SConnection *pCon,
NXDupdate(hdict,"strdim","132");
}
/*-------------------------------------------------------------------*/
static void writeChopper(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics){
SNXSPutVariable(pSics,pCon,hfil,hdict,"cname","choppername");
SNXSPutDrivable(pSics,pCon,hfil,hdict,"chopperspeed","crot");
static void writeChopper(NXhandle hfil, NXdict hdict, SConnection *pCon){
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"cname","choppername");
SNXSPutDrivable(pServ->pSics,pCon,hfil,hdict,"chopperspeed","crot");
}
/*-------------------------------------------------------------------*/
static void writeDiaphragm1(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics){
static void writeDiaphragm1(NXhandle hfil, NXdict hdict,
SConnection *pCon){
float dist;
SNXSPutMotor(pSics,pCon,hfil,hdict,"dia1x","d1m");
SNXSPutMotorNull(pSics,pCon,hfil,hdict,"dia1x0","d1m");
SNXSPutMotor(pSics,pCon,hfil,hdict,"dia1y","d1o");
SNXSPutMotorNull(pSics,pCon,hfil,hdict,"dia1y0","d1o");
SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"dia1x","d1m");
SNXSPutMotorNull(pServ->pSics,pCon,hfil,hdict,"dia1x0","d1m");
SNXSPutMotor(pServ->pSics,pCon,hfil,hdict,"dia1y","d1o");
SNXSPutMotorNull(pServ->pSics,pCon,hfil,hdict,"dia1y0","d1o");
dist = (float)DIA1DIST;
NXDputalias(hfil,hdict,"dia1dist",&dist);
}
/*------------------------------------------------------------------*/
static void writeDiaphragm2(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics){
float dist2;
static void writeDiaphragm2(NXhandle hfil, NXdict hdict,
SConnection *pCon){
SNXSPutMotor(pSics, pCon, hfil, hdict, "dia2x_plus", "d2m");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "dia2xplus0", "d2m");
SNXSPutMotor(pSics, pCon, hfil, hdict, "dia2x_minus", "d2u");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "dia2xminus0", "d2u");
SNXSPutMotor(pSics, pCon, hfil, hdict, "dia2z_plus", "d2o");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "dia2zplus0", "d2o");
SNXSPutMotor(pSics, pCon, hfil, hdict, "dia2z_minus", "d2l");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "dia2zminus0", "d2l");
dist2 = (float) DIA2DIST;
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "dia2x_plus", "d2m");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "dia2xplus0", "d2m");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "dia2x_minus", "d2u");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "dia2xminus0", "d2u");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "dia2z_plus", "d2o");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "dia2zplus0", "d2o");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "dia2z_minus", "d2l");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "dia2zminus0", "d2l");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"dia2dist","dia1_dia2");
}
/*--------------------------------------------------------------------*/
static void writeSample(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics)
static void writeSample(NXhandle hfil, NXdict hdict,
SConnection *pCon)
{
float sadist = (float)SADIST;
NXDputalias(hfil, hdict, "sdist", &sadist);
SNXSPutVariable(pSics,pCon,hfil,hdict,"saname","sample");
SNXSPutVariable(pSics,pCon,hfil,hdict,"senvir","environment");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"sdist","dia2_sample");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"chopperdist","chopper_sample");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"saname","sample");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"senvir","environment");
SNXSPutEVVar(hfil,hdict,"temperature",pCon,"stemp","stddev");
SNXSPutMotor(pSics, pCon, hfil, hdict, "srsu", "rsu");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "srsu0", "rsu");
SNXSPutMotor(pSics, pCon, hfil, hdict, "srsl", "rsl");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "srsl0", "rsl");
SNXSPutMotor(pSics, pCon, hfil, hdict, "srsa", "rsa");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "srsa0", "rsa");
SNXSPutMotor(pSics, pCon, hfil, hdict, "sshu", "shu");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "sshu0", "shu");
SNXSPutMotor(pSics, pCon, hfil, hdict, "sshl", "shl");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "sshl0", "shl");
SNXSPutMotor(pSics, pCon, hfil, hdict, "ssgu", "sgu");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "ssgu0", "sgu");
SNXSPutMotor(pSics, pCon, hfil, hdict, "ssgl", "sgl");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "ssgl0", "sgl");
SNXSPutMotor(pSics, pCon, hfil, hdict, "ssv", "sv");
SNXSPutMotorNull(pSics, pCon, hfil, hdict, "ssv0", "sv");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "srsu", "rsu");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "srsu0", "rsu");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "srsl", "rsl");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "srsl0", "rsl");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "srsa", "rsa");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "srsa0", "rsa");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "sshu", "shu");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "sshu0", "shu");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "sshl", "shl");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "sshl0", "shl");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "ssgu", "sgu");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "ssgu0", "sgu");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "ssgl", "sgl");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "ssgl0", "sgl");
SNXSPutMotor(pServ->pSics, pCon, hfil, hdict, "ssv", "sv");
SNXSPutMotorNull(pServ->pSics, pCon, hfil, hdict, "ssv0", "sv");
}
/*-----------------------------------------------------------------------*/
static void writeDetector(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics)
/*--------------------------------------------------------------------*/
static int PoldiStart(pPolterdi self, SConnection *pCon)
{
char pBueffel[256];
NXhandle hfil = NULL;
NXdict hdict= NULL;
int status;
const float *fTime = NULL;
CounterMode eMode;
pHistMem pHist= NULL;
float *fTime2 = NULL, fTheta[NODET], fVal;
int iLength, i;
char pBueffel[80];
float *fTime2 = NULL,fTheta0[801],fTheta[801], fVal;
pSicsVariable pVar = NULL;
float det_radius, det_size, x0det, y0det, twothet;
float pi, alpha1, alphasamp, sms, phidetav, phim;
float phi2det, val1, val2, nodet;
int iLength, i, nzell;
pMotor sa;
HistInt *lData = NULL;
long lVal;
pHist = (pHistMem)FindCommandData(pSics,HM,"HistMem");
if(!pHist)
/* create filename */
self->pFile = SNXMakeFileName(pServ->pSics,pCon);
if(!self->pFile)
{
SCWrite(pCon,"ERROR: Histogram memory NOT found",eError);
return;
SCWrite(pCon,"ERROR: Extra severe: failed to create data file name",
eError);
return 0;
}
/* create a Nexus file */
NXopen(self->pFile,NXACC_CREATE,&hfil);
if(!hfil)
{
SCWrite(pCon,"ERROR: cannot create data file ",eError);
return 0;
}
/* tell Uwe User what we are doing */
sprintf(pBueffel,"Writing %s ......",self->pFile);
SCWrite(pCon,pBueffel,eWarning);
/* write globals */
SNXSPutGlobals(hfil,self->pFile,"POLDI",pCon);
/* open nxdict */
status = NXDinitfromfile(self->dictfile,&hdict);
if(status != NX_OK)
{
sprintf(pBueffel,"ERROR: failed to open dictionary file %s",
self->dictfile);
SCWrite(pCon,pBueffel,eError);
SCWrite(pCon,"ERROR: Aborting data file writing",eError);
SCWrite(pCon,"ERROR: This is a SERIOUS problem!",eError);
SCWrite(pCon,"ERROR: DATA NOT WRITTEN",eError);
NXclose(&hfil);
return 0;
}
writePolterdiGlobal(hfil,hdict,pCon);
writeChopper(hfil,hdict,pCon);
writeDiaphragm1(hfil,hdict,pCon);
writeDiaphragm2(hfil,hdict,pCon);
writeSample(hfil,hdict,pCon);
/*
write time binning
*/
fTime = GetHistTimeBin(pHist,&iLength);
fTime = GetHistTimeBin(self->pHist,&iLength);
fTime2 = (float *)malloc(iLength*sizeof(float));
if(fTime2)
{
@ -226,31 +339,100 @@ static void writeDetector(NXhandle hfil, NXdict hdict, SConnection *pCon,
}
/*
do theta
theta calculation
*/
fVal = -999.;
sa = FindMotor(pSics,"sa");
if(sa)
det_radius = (float)DETRADIUS;
pVar = FindVariable(pServ->pSics,"det_size");
if(pVar)
{
MotorGetSoftPosition(sa,pCon,&fVal);
VarGetFloat(pVar,&det_size);
} else {
SCWrite(pCon,"ERROR: Command not found!",eError);
return;
}
else
pVar = NULL;
pVar = FindVariable(pServ->pSics,"nodet");
if(pVar)
{
SCWrite(pCon,"ERROR: failed to locate two theta motor",eError);
VarGetFloat(pVar,&nodet);
} else {
SCWrite(pCon,"ERROR: Command not found!",eError);
return;
}
for(i = 0; i < NODET; i++)
pVar = NULL;
nzell = (int)nodet;
pVar = FindVariable(pServ->pSics,"x0_det");
if(pVar)
{
fTheta[i] = fVal + i * THSPACE;
VarGetFloat(pVar,&x0det);
} else {
SCWrite(pCon,"ERROR: Command not found!",eError);
return;
}
pVar = NULL;
pVar = FindVariable(pServ->pSics,"y0_det");
if(pVar)
{
VarGetFloat(pVar, &y0det);
} else {
SCWrite(pCon,"ERROR: Command not found!",eError);
return;
}
pVar = NULL;
pVar = FindVariable(pServ->pSics,"twotheta");
if(pVar)
{
VarGetFloat(pVar, &twothet);
} else {
SCWrite(pCon,"ERROR: Command not found!",eError);
return;
}
pi = 3.1415926536;
/* transformation to radient */
twothet = twothet*pi/180;
if (x0det < 0) {
alpha1 = atan(y0det/x0det);
}
if (x0det > 0) {
alpha1 = pi + atan(y0det/x0det);
}
alphasamp=pi + alpha1 - twothet;
sms = sqrt(x0det*x0det + y0det*y0det);
phidetav = pi - alphasamp - asin(sms/det_radius*sin(alphasamp)) + alpha1;
phim = atan(y0det/x0det);
if (phim < 0) {
phim = pi + phim;
}
for(i = 0; i <= nzell; i++)
{
phi2det = phidetav+(i-0.5*(nzell-1.0))*det_size/(det_radius);
val1 = det_radius*sin(phi2det) - sms*sin(phim);
val2 = det_radius*cos(phi2det) - sms*cos(phim);
fTheta0[i] = atan(val1/val2);
if (fTheta0[i] < 0) {
fTheta0[i] = pi + fTheta0[i];
}
/* transformation to degree */
fTheta0[i] = fTheta0[i]*180/pi;
}
for (i=0;i<=nzell;i++)
{
fTheta[i]=fTheta0[nzell-i];
}
NXDputalias(hfil,hdict,"dtheta",fTheta);
fVal = (float)DETDIST;
NXDputalias(hfil,hdict,"ddist",&fVal);
NXDputalias(hfil,hdict,"detector_radius",&det_radius);
NXDputalias(hfil,hdict,"cell_size",&det_size);
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"ddist","detectordist");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"sangle","scatt_angle");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"detx0","x0_det");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"dety0","y0_det");
SNXSPutVariable(pServ->pSics,pCon,hfil,hdict,"theta","twotheta");
/*
write Histogram
*/
lData = GetHistogramPointer(pHist,pCon);
lData = GetHistogramPointer(self->pHist,pCon);
if(lData)
{
NXDputalias(hfil,hdict,"dcounts",lData);
@ -263,11 +445,11 @@ static void writeDetector(NXhandle hfil, NXdict hdict, SConnection *pCon,
/*
write counting data
*/
fVal = GetHistCountTime(pHist,pCon);
fVal = GetHistCountTime(self->pHist,pCon);
NXDputalias(hfil,hdict,"cntime",&fVal);
lVal = GetHistMonitor(pHist,1,pCon);
lVal = GetHistMonitor(self->pHist,1,pCon);
NXDputalias(hfil,hdict,"cnmon1",&lVal);
eMode = GetHistCountMode(pHist);
eMode = GetHistCountMode(self->pHist);
if(eMode == eTimer)
{
strcpy(pBueffel,"timer");
@ -277,55 +459,45 @@ static void writeDetector(NXhandle hfil, NXdict hdict, SConnection *pCon,
strcpy(pBueffel,"monitor");
}
NXDputalias(hfil,hdict,"cnmode",pBueffel);
fVal = GetHistPreset(pHist);
fVal = GetHistPreset(self->pHist);
NXDputalias(hfil,hdict,"cnpreset",&fVal);
/* close everything */
NXclose(&hfil);
NXDclose(hdict,NULL);
self->iNew = 0;
}
/*---------------------------------------------------------------------*/
static void makeLinks(NXhandle hfil, NXdict hdict, SConnection *pCon,
SicsInterp *pSics)
{
NXDaliaslink(hfil,hdict,"dana","dcounts");
NXDaliaslink(hfil,hdict,"dana","dtheta");
NXDaliaslink(hfil,hdict,"dana","dtime");
}
/*--------------------------------------------------------------------*/
static int StoreData(SConnection *pCon, SicsInterp *pSics, pPolterdi self)
{
char pBueffel[256], *pFile = NULL;
NXhandle hfil = NULL;
NXdict hdict= NULL;
int status;
/* create filename */
pFile = SNXMakeFileName(pSics,pCon);
if(!pFile)
/*---------------------------------------------------------------------------*/
static void PoldiUpdate(pPolterdi self, SConnection *pCon)
{
SCWrite(pCon,"ERROR: Extra severe: failed to create data file name",
eError);
return 0;
}
char pBueffel[256];
NXhandle hfil = NULL;
NXdict hdict = NULL;
int status;
const float *fTime = NULL;
CounterMode eMode;
float *fTime2 = NULL, fTheta[801], fVal;
pSicsVariable pVar = NULL;
float det_radius, det_size, x0det, y0det, twothet;
float pi, alpha1, alphasamp, sms, phidetav, phim;
float phi2det, val1, val2, nodet;
int iLength, i, nzell;
pMotor sa;
HistInt *lData = NULL;
long lVal;
/* create a Nexus file */
NXopen(pFile,NXACC_CREATE,&hfil);
if(!hfil)
{
SCWrite(pCon,"ERROR: cannot create data file ",eError);
return 0;
}
/* tell Uwe User what we are doing */
sprintf(pBueffel,"Writing %s ......",pFile);
SCWrite(pCon,pBueffel,eWarning);
/* write globals */
SNXSPutGlobals(hfil,pFile,"POLTERDI",pCon);
free(pFile);
pFile = NULL;
/* open nxdict */
status = NXDinitfromfile(self->dictfile,&hdict);
if(status != NX_OK)
{
/* open everything again */
NXopen(self->pFile,NXACC_RDWR,&hfil);
if(!self->pFile)
{
SCWrite(pCon,"ERROR: cannot reopen data file ",eError);
return;
}
status = NXDinitfromfile(self->dictfile,&hdict);
if(status != NX_OK)
{
sprintf(pBueffel,"ERROR: failed to open dictionary file %s",
self->dictfile);
SCWrite(pCon,pBueffel,eError);
@ -333,42 +505,240 @@ static int StoreData(SConnection *pCon, SicsInterp *pSics, pPolterdi self)
SCWrite(pCon,"ERROR: This is a SERIOUS problem!",eError);
SCWrite(pCon,"ERROR: DATA NOT WRITTEN",eError);
NXclose(&hfil);
return 0;
return;
}
/* tell the user that something is happening */
sprintf(pBueffel,"Updating %s",self->pFile);
SCWrite(pCon,pBueffel,eWarning);
/*
write time binning
*/
fTime = GetHistTimeBin(self->pHist,&iLength);
fTime2 = (float *)malloc(iLength*sizeof(float));
if(fTime2)
{
for(i = 0;i < iLength; i++)
{
fTime2[i] = fTime[i]/10.;
}
sprintf(pBueffel,"%d",iLength);
NXDupdate(hdict,"timebin",pBueffel);
NXDputalias(hfil,hdict,"dtime",fTime2);
free(fTime2);
}
else
{
SCWrite(pCon,"ERROR: out of memory while writing time binning",eError);
}
/*
write Histogram
*/
writePolterdiGlobal(hfil,hdict,pCon,pSics);
lData = GetHistogramPointer(self->pHist,pCon);
if(lData)
{
NXDputalias(hfil,hdict,"dcounts",lData);
}
else
{
SCWrite(pCon,"ERROR: failed to get histogram data",eError);
}
writeChopper(hfil,hdict,pCon,pSics);
/*
write counting data
*/
fVal = GetHistCountTime(self->pHist,pCon);
NXDputalias(hfil,hdict,"cntime",&fVal);
lVal = GetHistMonitor(self->pHist,1,pCon);
NXDputalias(hfil,hdict,"cnmon1",&lVal);
eMode = GetHistCountMode(self->pHist);
if(eMode == eTimer)
{
strcpy(pBueffel,"timer");
}
else
{
strcpy(pBueffel,"monitor");
}
NXDputalias(hfil,hdict,"cnmode",pBueffel);
fVal = GetHistPreset(self->pHist);
NXDputalias(hfil,hdict,"cnpreset",&fVal);
writeDiaphragm1(hfil,hdict,pCon,pSics);
writeDiaphragm2(hfil,hdict,pCon,pSics);
/* close everything */
NXclose(&hfil);
NXDclose(hdict,NULL);
writeSample(hfil,hdict,pCon,pSics);
}
writeDetector(hfil,hdict,pCon,pSics);
/*-------------------------------------------------------------------------
FoLink sets all the links for the NXdata vGroup. Had to be separate because
at least one update is necessary before this can be done.
-------------------------------------------------------------------------*/
makeLinks(hfil,hdict,pCon,pSics);
static void PoldiLink(pPolterdi self, SConnection *pCon)
{
NXhandle hfil = NULL;
NXdict hdict = NULL;
int status;
char pBueffel[512];
/* close everything */
NXclose(&hfil);
NXDclose(hdict,NULL);
/* open everything again */
NXopen(self->pFile,NXACC_RDWR,&hfil);
if(!self->pFile)
{
SCWrite(pCon,"ERROR: cannot reopen data file ",eError);
return;
}
status = NXDinitfromfile(self->dictfile,&hdict);
if(status != NX_OK)
{
sprintf(pBueffel,"ERROR: failed to open dictionary file %s",
self->dictfile);
SCWrite(pCon,pBueffel,eError);
SCWrite(pCon,"ERROR: Aborting data file writing",eError);
SCWrite(pCon,"ERROR: This is a SERIOUS problem!",eError);
SCWrite(pCon,"ERROR: DATA NOT WRITTEN",eError);
NXclose(&hfil);
return;
}
SCSendOK(pCon);
return 1;
}
NXDaliaslink(hfil,hdict,"dana","dcounts");
NXDaliaslink(hfil,hdict,"dana","dtheta");
NXDaliaslink(hfil,hdict,"dana","dtime");
/* close everything */
NXclose(&hfil);
NXDclose(hdict,NULL);
}
/*---------------------------------------------------------------------------
This is the task function for updating the data file any now and then
automatically
--------------------------------------------------------------------------*/
static int PoldiTask(void *pData)
{
pPolterdi self = NULL;
int iWrite, iRet;
self = (pPolterdi)pData;
if(!self)
return 0;
/* figure out if we need to write */
iWrite = 0;
iRet = 1;
/* first case: update intervall */
if(time(NULL) >= self->tUpdate)
{
self->tUpdate = time(NULL) + self->iInterval;
iWrite = 1;
iRet = 1;
}
if(self->iEnd)
{
self->tUpdate = 0;
SCWrite(self->pCon,"Writing finished!",eError);
iWrite = 0;
iRet = 0;
}
if(iWrite)
{
if(self->iNew)
{
PoldiStart(self,self->pCon);
PoldiUpdate(self,self->pCon);
PoldiLink(self,self->pCon);
}
else
{
PoldiUpdate(self,self->pCon);
PoldiLink(self,self->pCon);
}
}
return iRet;
}
/*----------------------------------------------------------------------*/
int PolterAction(SConnection *pCon, SicsInterp *pSics,
void *pData, int argc, char *argv[])
{
pPolterdi self = (pPolterdi)pData;
int iRet, iVal;
pPolterdi self = NULL;
char pBueffel[512];
assert(self);
assert(pCon);
assert(pSics);
if(argc < 2)
{
SCWrite(pCon,"ERROR: Insufficient number of arguments to StoreData",
eError);
return 0;
}
return StoreData(pCon,pSics,self);
self = (pPolterdi)pData;
assert(self);
strtolower(argv[1]);
if(strcmp(argv[1],"start") == 0)
{
PoldiStart(self,pCon);
PoldiUpdate(self,pCon);
PoldiLink(self,pCon);
return 1;
} else if(strcmp(argv[1],"update") == 0)
{
if((self->iNew) || (!self->pFile))
{
PoldiStart(self,pCon);
}
else
{
PoldiUpdate(self,pCon);
PoldiLink(self,pCon);
}
return 1;
}
else if(strcmp(argv[1],"getfile") == 0)
{
sprintf(pBueffel,"StoreData.file = %s",self->pFile);
SCWrite(pCon,pBueffel,eValue);
return 1;
}
else if(strcmp(argv[1],"interval") == 0)
{
if(argc > 2) /* set value */
{
if(!SCMatchRights(pCon,usUser))
{
return 0;
}
iRet = Tcl_GetInt(pSics->pTcl,argv[2],&iVal);
if(iRet != TCL_OK)
{
sprintf(pBueffel,"ERROR: cannot convert --> %s <-- to number ",
argv[2]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
self->iInterval = iVal*60; /* go to seconds from minutes*/
SCSendOK(pCon);
return 1;
}
else /* read the value */
{
sprintf(pBueffel,"storefocus.interval = %d",self->iInterval/60);
SCWrite(pCon,pBueffel,eValue);
return 1;
}
}
SCWrite(pCon,"ERROR: subcommand to StoreData not recognized",eError);
return 0;
}

12
sicsstatus.tcl
View File

@ -47,11 +47,11 @@ ps.phiend setAccess 2
ps.phistart 0.000000
ps.phistart setAccess 2
hm3 CountMode timer
hm3 preset 10.000000
hm2 CountMode monitor
hm2 preset 2.000000
hm1 CountMode monitor
hm1 preset 2.000000
hm3 preset 3600.000000
hm2 CountMode timer
hm2 preset 3600.000000
hm1 CountMode timer
hm1 preset 3600.000000
#Crystallographic Settings
hkl lambda 1.179000
hkl setub -0.017880 -0.074923 0.028280 -0.007008 -0.036800 -0.057747 0.160912 -0.009928 0.000627
@ -458,5 +458,5 @@ sample D20 30K SNP Okt 2001 GS
sample setAccess 2
title snp gs apd 30K
title setAccess 2
starttime 2001-11-16 08:55:46
starttime 2002-04-23 10:49:18
starttime setAccess 2

8
sinqhm/FOCUS_srv_main.c
View File

@ -1590,7 +1590,7 @@
int my_daq_save;
uint maxbins, my_nbins, bins_in_buff;
uint nxtbin_to_send, nbins_to_send, bytes_in_buff;
uint bins_to_go;
uint bins_to_go, lastbin;
struct req_buff_struct my_rqst;
struct rply_buff_struct my_rply;
uchar *buff_pntr, *last_byte, *nxt;
@ -1710,9 +1710,13 @@
nxt = (char *) my_pntr.base;
while (nbins_to_send > 0) {
/* Read some histogram data into buffer */
lastbin = nxtbin_to_send + bins_in_buff;
if(lastbin > my_nbins-1){
lastbin = my_nbins-1;
}
bins_to_go = FS_read_hm (index, pkt_size,
my_pntr.base, bins_in_buff,
nxtbin_to_send, (my_fstbin + my_nbins - 1));
nxtbin_to_send, lastbin);
if (bins_to_go <= 0) {
perror (StrJoin (buff, pkt_size,
FS_name[index], "/FS_do_read: FS_read_hm error"));

28
sinqhm/SinqHM_srv_filler.c
View File

@ -808,6 +808,10 @@
/*
We have a valid PSD packet. Find and check positions.
*/
/*
old style calculation, left in for now
xPos = xData.ui2[1];
if(xPos > 32767)
xPos -= 65536;
@ -816,20 +820,20 @@
if(yPos > 32767)
yPos -= 65536;
/*
if(xPos > 0)
xPos =(int)((float)xPos/(float)psdXFactor +.5 + psdXOffset);
else
xPos =(int)((float)xPos/(float)psdXFactor -.49999 + psdXOffset);
if(yPos > 0)
yPos =(int)((float)yPos/(float)psdYFactor +.5 + psdYOffset);
else
yPos =(int)((float)yPos/(float)psdYFactor -.49999 + psdYOffset);
*/
xPos = (int) ( (float)(xPos+xOff)/(float)psdXFactor);
yPos = (int)( (float)(yPos+yOff)/(float)psdYFactor);
*/
/*
This is the new version where all values are offset by 4096
in order to give positive values at all times. This relates
to a zero point in the middle of the detector. As we want a
zero point in the lower left corner, we subtract 2048.
*/
xPos = xData.ui2[1];
xPos = (xPos - 2048)/psdXFactor;
yPos = yData.ui2[1];
yPos = (yPos - 2048)/psdYFactor;
if(xPos < 0 || xPos > psdXSize)

2
sinqhm/SinqHM_srv_main.c
View File

@ -151,7 +151,7 @@
Dbg_mask = 0;
Dbg_lev0 = 0;
Dbg_lev1 = 1;
Dbg_lev1 = 0;
Dbg_lev2 = 0;
Dbg_lev3 = 0;
Cfgn_done = 0; /* Force a configuration before we can do anything. */

2
sinqhm/SinqHM_srv_routines.c
View File

@ -1205,7 +1205,7 @@
/*
switch debugging on by default
Dbg_lev1 = 1;
Dbg_lev1 = 0;
*/
/*

11
tascom.tcl
View File

@ -495,8 +495,10 @@ proc co args {
#----- format output
set cts [tasSplit [counter getcounts]]
set m1 [tasSplit [counter getmonitor 1]]
set m3 [tasSplit [counter getmonitor 2]]
return [format " Counts = %8d, M1 = %8d, M3 = %8d" $cts $m1 $m3]
set m2 [tasSplit [counter getmonitor 2]]
set m3 [tasSplit [counter getmonitor 3]]
return [format " Counts = %8d, M1 = %8d, M2 = %8d, M3 = %8d" \
$cts $m1 $m2 $m3]
}
#----------------------------------------------------------------------------
@ -775,7 +777,7 @@ proc le args {
set v2 [tasSplit [qm]]
set val [format " %9.4f %9.4f\n" $v1 $v2]
set v1 [tasSplit [ten]]
set v2 [tasSplit [qm]]
set v2 [tasSplit [tqm]]
set val2 [format " %9.4f %9.4f\n" $v1 $v2]
append output [format "POSN: %s" $val]
append output [format "TARG: %s" $val2]
@ -926,8 +928,7 @@ proc sz args {
"%-8sOld: %8.2f %8.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n" \
$mot $loh $los $pos $targ $his $hih $zero]
#-------action
set newZero [expr $zero + ($val - $pos)]
madZero $mot $newZero
madZero $mot $val
catch {updateqe} msg
#-------- more output
set zero [tasSplit [madZero $mot]]

5
tasinit.c
View File

@ -48,6 +48,7 @@ extern char *tasMotorOrder[] = { "a1",
"sgl",
"sgu",
"agl",
"tt",
"i1" ,
"i2",
"i3",
@ -211,10 +212,10 @@ static int MonitorCallback(int iEvent, void *pEvent, void *pUser)
return 0;
SetCounterMode(self->pScan->pCounterData,ePreset);
SetCounterPreset(self->pScan->pCounterData,self->tasPar[MN]->fVal);
SetCounterPreset(self->pScan->pCounterData,(float)self->tasPar[MN]->iVal);
return 1;
}
/*---------------------------------------------------------------------*/
static int TimerCallback(int iEvent, void *pEvent, void *pUser)
{
pTASdata self = (pTASdata)pUser;

2
trics.dic
View File

@ -52,6 +52,8 @@ framemode = /$(framename),NXentry/TRICS,NXinstrument/count_control,NXcounter/SDS
framemonitor = /$(framename),NXentry/TRICS,NXinstrument/count_control,NXcounter/SDS monitor -type DFNT_INT32
sinqmonitor= /$(framename),NXentry/TRICS,NXinstrument/count_control,NXcounter/SDS beam_monitor \
-type DFNT_INT32
cctime= /$(framename),NXentry/TRICS,NXinstrument/count_control,NXcounter/SDS \
time -attr {units,seconds}
#------------------------ Detector
dnumber = detector1
framedim1 = 256