linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f3853c20f0868e2396766978712d5bab75206705
sics/faverage.c
cvs f3853c20f0 - Fixed bug with ECB not stopping when no beam 
- Fixed synchronisation issues
- Fixed hsitogram memory writing from nxscript
- Started module for writing SICS interfaces in Tcl
- Fixed a bug in scan, which allowed to corrupt files
- Fixed memory problems in napi5
2003-05-23 15:06:47 +00:00

558 lines
15 KiB
C
Raw Blame History

/*---------------------------------------------------------------------------
F o c u s A v e r a g e r
A little averager for FOCUS data. Used by the FOCUS status display.
copyright: see copyright.h
Mark Koennecke, October 1998
Updated for additional detector banks
Mark Koennecke, March 2000
Added focusraw command for retrieving single detector banks in support
of the colour mapping part of the FOCUS status display.
Mark Koennecke, July 2001
---------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include <tcl.h>
#include <time.h>
#include "fortify.h"
#include "sics.h"
#include "sicsvar.h"
#include "counter.h"
#include "HistMem.h"
#include "fomerge.h"
#include "faverage.h"
/*
#define DEB 1
*/
/*-------------------------------------------------------------------------*/
typedef struct __FocusAverager {
pObjectDescriptor pDes;
pHistMem pHistogram1;
pHistMem pHistogram2;
pHistMem pHistogram3;
} FocusAverager, *pFocusAverager;
/*------------------------------------------------------------------------*/
HistInt *CheckBank(pFocusAverager self, SConnection *pCon,
int iLength, int iBank);
static void KillFA(void *pData)
{
pFocusAverager self = NULL;
self = (pFocusAverager)pData;
if(!self)
return;
if(self->pDes)
DeleteDescriptor(self->pDes);
free(self);
}
/*-------------------------------------------------------------------------*/
int FocusAverageDo(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[])
{
pFocusAverager self = NULL;
int *iData = NULL;
const float *fTimeBin = NULL;
float fVal;
int iLength, iStart, iEnd, iNum, i,ii, iTest, iBufLen, iRet, iVal;
char pBueffel[256];
HistInt *hiData = NULL, *hiPtr;
time_t tStart, tEnd;
int iBank = MIDDLE;
pSicsVariable var1 = NULL;
pSicsVariable var2 = NULL;
pSicsVariable var3 = NULL;
int lbank, mbank, ubank;
self = (pFocusAverager)pData;
assert(self);
assert(pCon);
assert(pSics);
/* we need two parameters: start and end of averaging */
if(argc < 3)
{
SCWrite(pCon,
"ERROR: insufficient number of parameters for FocusAverage",
eError);
return 0;
}
iRet = Tcl_GetInt(pSics->pTcl,argv[1],&iStart);
if(iRet != TCL_OK)
{
sprintf(pBueffel,"ERROR: cannot convert %d to integer",argv[1]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
iRet = Tcl_GetInt(pSics->pTcl,argv[2],&iEnd);
if(iRet != TCL_OK)
{
sprintf(pBueffel,"ERROR: cannot convert %d to integer",argv[2]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
/* another parameter, if available describes the detector bank
*/
if(argc > 3)
{
iRet = Tcl_GetInt(pSics->pTcl,argv[3],&iBank);
if(iRet != TCL_OK)
{
sprintf(pBueffel,"ERROR: cannot convert %d to integer",argv[3]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
}
/* how much to do: correct parameters? */
iNum = iEnd - iStart;
if(iNum < 0)
{
SCWrite(pCon,"ERROR: invalid parameters given to FocusAverage",
eError);
return 0;
}
/* may be only one histogram requested */
if(iNum == 0)
iNum = 1;
if(iStart < 0)
{
SCWrite(pCon,"ERROR: invalid parameters given to FocusAverage",
eError);
return 0;
}
#ifdef DEB
printf("Starting averaging ...\n");
fflush(stdout);
tStart = time(NULL);
#endif
/* do work! first retrieve time binning data */
var2 = FindVariable(pServ->pSics,"mbank");
if(var2)
{
VarGetInt(var2,&mbank);
} else {
SCWrite(pCon,"ERROR: mbank value not found!",eError);
}
if(mbank==1)
{
fTimeBin = GetHistTimeBin(self->pHistogram2,&iLength);
}
else
{
var1 = FindVariable(pServ->pSics,"lbank");
if(var1)
{
VarGetInt(var1,&lbank);
} else {
SCWrite(pCon,"ERROR: lbank value not found!",eError);
}
if(lbank==1)
{
fTimeBin = GetHistTimeBin(self->pHistogram1,&iLength);
}
else
{
fTimeBin = GetHistTimeBin(self->pHistogram3,&iLength);
}
}
assert(fTimeBin);
if(iLength <= 0)
{
SCWrite(pCon,"ERROR: histogram memory inproperly configured",eError);
return 0;
}
/* allocate result data */
iBufLen = (iLength *2 +1)*sizeof(int);
iData = (int *)malloc(iBufLen);
memset(iData,0,iBufLen);
/* get histogram length */
i = getFMdim(iBank);
/* correct iEnd to maximum allowed */
iTest = i;
if(iEnd > iTest -1)
{
iEnd = iTest - 1;
iNum = iEnd - iStart;
if(iNum <= 0)
iNum = 1;
}
#ifdef DEB
printf("Getting histogram....\n");
fflush(stdout);
#endif
hiData = CheckBank(self,pCon,iLength,iBank);
#ifdef DEB
tEnd = time(NULL);
printf("Histogram received in %d seconds\n", tStart - tEnd);
fflush(stdout);
#endif
if(hiData == NULL)
{
SCWrite(pCon,"ERROR: BAD Configuration",eError);
free(iData);
return 0;
}
/* first int: length of things to come */
iData[0] = htonl(iLength);
/* sum up */
for(i = iStart; i < iEnd; i++)
{
hiPtr = hiData + i*iLength;
for(ii = 0; ii < iLength; ii++)
{
iData[ii+1] += hiPtr[ii];
}
}
/* average */
for(i = 1; i < iLength + 1; i++)
{
fVal = (float)iData[i]/(float)iNum;
fVal *= 65536.;
iData[i] = htonl((int)fVal);
}
/* make time binning fixed point */
for(i = 0; i < iLength; i++)
{
fVal = fTimeBin[i]/10.;
fVal *= 65536.;
iData[iLength+1+i] = htonl((int)fVal);
}
#ifdef DEB
printf("Sending averaged data....\n");
fflush(stdout);
#endif
/* finally send out uuencoded */
SCWriteUUencoded(pCon,"FocusAverage",iData,iBufLen);
if(iData)
free(iData);
#ifdef DEB
printf("Averaging finished\n");
fflush(stdout);
#endif
return 1;
}
/*-------------------------------------------------------------------------*/
static int FocusRaw(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[])
{
pFocusAverager self = NULL;
int *iData = NULL;
int iLength, noTimebin, iRet, i;
char pBueffel[256];
const float *timeBin;
HistInt *hiData = NULL, *hiPtr;
int iBank = MIDDLE;
pSicsVariable var1 = NULL;
pSicsVariable var2 = NULL;
pSicsVariable var3 = NULL;
int lbank, mbank, ubank;
self = (pFocusAverager)pData;
assert(self);
assert(pCon);
assert(pSics);
/* we need one parameter, the bank to read */
if(argc < 2)
{
SCWrite(pCon,
"ERROR: insufficient number of parameters for FocusRaw",
eError);
return 0;
}
iRet = Tcl_GetInt(pSics->pTcl,argv[1],&iBank);
if(iRet != TCL_OK)
{
sprintf(pBueffel,"ERROR: cannot convert %d to integer",argv[1]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
var2 = FindVariable(pServ->pSics,"mbank");
if(var2)
{
VarGetInt(var2,&mbank);
} else {
SCWrite(pCon,"ERROR: mbank value not found!",eError);
}
if(var2)
{
timeBin = GetHistTimeBin(self->pHistogram2,&iLength);
}
else
{
var1 = FindVariable(pServ->pSics,"lbank");
if(var1)
{
VarGetInt(var1,&lbank);
} else {
SCWrite(pCon,"ERROR: lbank value not found!",eError);
}
if(var1)
{
timeBin = GetHistTimeBin(self->pHistogram1,&iLength);
}
else
{
timeBin = GetHistTimeBin(self->pHistogram3,&iLength);
}
}
assert(timeBin);
hiData = CheckBank(self, pCon, iLength, iBank);
/* get histogram length */
iLength = getFMdim(iBank);
noTimebin = getFMdim(TIMEBIN);
/* write dimension info*/
sprintf(pBueffel,"focusrawdim = %d = %d", iLength, noTimebin);
SCWrite(pCon,pBueffel,eValue);
/* allocate space */
iData = (int *)malloc((iLength*noTimebin+1)*sizeof(int));
if(iData == NULL)
{
SCWrite(pCon,"ERROR: out of memory in FocusRaw",eError);
return 0;
}
memset(iData,0,noTimebin*iLength*sizeof(int));
/* first int: length of things to come */
iData[0] = htonl(iLength*noTimebin);
/* network byte order for everything */
for(i = 0; i < noTimebin*iLength; i++)
{
iData[i+1] = htonl(hiData[i]);
}
/* send away, zipped */
SCWriteZipped(pCon,"focusraw",iData,(iLength*noTimebin+1)*sizeof(int));
free(iData);
return 1;
}
/*-------------------------------------------------------------------------*/
int MakeFA(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[])
{
pFocusAverager pNew = NULL;
CommandList *pCom = NULL;
pDummy pDum = NULL;
char pBueffel[256];
int iRet;
pSicsVariable var1 = NULL;
pSicsVariable var2 = NULL;
pSicsVariable var3 = NULL;
int lbank, mbank, ubank;
assert(pCon);
assert(pSics);
/* we need two parameters: the name for the averager and the histogram
memory
*/
if(argc < 3)
{
SCWrite(pCon,"ERROR: Insufficient number of parameters to MakeFA",
eError);
return 0;
}
/* find histogram memory */
pCom = FindCommand(pSics,argv[2]);
if(!pCom)
{
sprintf(pBueffel,"ERROR: histogram memory %s NOT found!", argv[2]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
pDum = (pDummy)pCom->pData;
if(!pDum)
{
sprintf(pBueffel,"ERROR: histogram memory %s INVALID!", argv[2]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
if(strcmp(pDum->pDescriptor->name,"HMcontrol") != 0)
{
sprintf(pBueffel,"ERROR: %s is NO histogram control object!", argv[2]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
/* we got what we need: set things up */
pNew = (pFocusAverager)malloc(sizeof(FocusAverager));
if(!pNew)
{
SCWrite(pCon,"ERROR: out of memory in MakeFA",eError);
return 0;
}
memset(pNew,0,sizeof(FocusAverager));
pNew->pDes = CreateDescriptor("FocusAverager");
if(!pNew->pDes)
{
SCWrite(pCon,"ERROR: out of memory in MakeFA",eError);
return 0;
}
var2 = FindVariable(pServ->pSics,"mbank");
if(var2)
{
VarGetInt(var2,&mbank);
} else {
SCWrite(pCon,"ERROR: mbank value not found!",eError);
}
if(mbank==1)
{
pCom = FindCommand(pSics,"hm2");
pDum = (pDummy)pCom->pData;
pNew->pHistogram2 = (pHistMem)pDum;
}
var1 = FindVariable(pServ->pSics,"lbank");
if(var1)
{
VarGetInt(var1,&lbank);
} else {
SCWrite(pCon,"ERROR: lbank value not found!",eError);
}
if(lbank==1)
{
pCom = FindCommand(pSics,"hm1");
pDum = (pDummy)pCom->pData;
pNew->pHistogram1 = (pHistMem)pDum;
}
var3 = FindVariable(pServ->pSics,"ubank");
if(var3)
{
VarGetInt(var3,&ubank);
} else {
SCWrite(pCon,"ERROR: ubank value not found!",eError);
}
if(ubank==1)
{
pCom = FindCommand(pSics,"hm3");
pDum = (pDummy)pCom->pData;
pNew->pHistogram3 = (pHistMem)pDum;
}
iRet = AddCommand(pSics,argv[1],FocusAverageDo, KillFA, pNew);
if(!iRet)
{
sprintf(pBueffel,"ERROR: duplicate command %s not created", argv[1]);
SCWrite(pCon,pBueffel,eError);
KillFA(pNew);
return 0;
}
iRet = AddCommand(pSics,"focusraw",FocusRaw, NULL, pNew);
if(!iRet)
{
sprintf(pBueffel,"ERROR: duplicate command focusraw not created");
SCWrite(pCon,pBueffel,eError);
return 0;
}
return 1;
}
HistInt *CheckBank(pFocusAverager self, SConnection *pCon,
int iLength, int iBank)
{
pSicsVariable var1 = NULL;
pSicsVariable var2 = NULL;
pSicsVariable var3 = NULL;
HistInt *lData = NULL;
HistInt *mData = NULL;
HistInt *uData = NULL;
HistInt *mergData = NULL;
int lbank, mbank, ubank;
if (iBank==2)
{
var2 = FindVariable(pServ->pSics,"mbank");
if(var2)
{
VarGetInt(var2,&mbank);
} else {
SCWrite(pCon,"ERROR: mbank value not found!",eError);
}
if(mbank==1)
{
mData = GetHistogramPointer(self->pHistogram2,pCon);
if(mData == NULL)
{
return NULL;
}
setFMDataPointer(mData, iLength,2);
mData = getFMBankPointer(2);
return mData;
}
}
if (iBank==3)
{
var1 = FindVariable(pServ->pSics,"lbank");
if(var1)
{
VarGetInt(var1,&lbank);
} else {
SCWrite(pCon,"ERROR: lbank value not found!",eError);
}
if(lbank==1)
{
lData = GetHistogramPointer(self->pHistogram1,pCon);
if(lData == NULL)
{
return NULL;
}
setFMDataPointer(lData, iLength, 3);
lData = getFMBankPointer(3);
return lData;
}
}
if (iBank==1)
{
var3 = FindVariable(pServ->pSics,"ubank");
if(var3)
{
VarGetInt(var3,&ubank);
} else {
SCWrite(pCon,"ERROR: ubank value not found!",eError);
}
if(ubank==1)
{
uData = GetHistogramPointer(self->pHistogram3,pCon);
if(uData == NULL)
{
return NULL;
}
setFMDataPointer(uData, iLength, 1);
uData = getFMBankPointer(1);
return uData;
}
}
if (iBank==4)
{
setFMDataPointer(mergData, iLength,4);
mergData = getFMBankPointer(4);
return mergData;
}
}
Reference in New Issue View Git Blame Copy Permalink