304 lines
8.3 KiB
C
304 lines
8.3 KiB
C
/*---------------------------------------------------------------------------
|
|
H I S T D R I V
|
|
|
|
This file contains the definitions of a few functions which are general
|
|
to all Histogram memory drivers.
|
|
|
|
Mark Koennecke, April 1997
|
|
|
|
Copyright:
|
|
|
|
Labor fuer Neutronenstreuung
|
|
Paul Scherrer Institut
|
|
CH-5423 Villigen-PSI
|
|
|
|
|
|
The authors hereby grant permission to use, copy, modify, distribute,
|
|
and license this software and its documentation for any purpose, provided
|
|
that existing copyright notices are retained in all copies and that this
|
|
notice is included verbatim in any distributions. No written agreement,
|
|
license, or royalty fee is required for any of the authorized uses.
|
|
Modifications to this software may be copyrighted by their authors
|
|
and need not follow the licensing terms described here, provided that
|
|
the new terms are clearly indicated on the first page of each file where
|
|
they apply.
|
|
|
|
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
|
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
|
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
|
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
|
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
|
MODIFICATIONS.
|
|
----------------------------------------------------------------------------*/
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <math.h>
|
|
#include "fortify.h"
|
|
#include "conman.h"
|
|
#include "obdes.h"
|
|
#include "interface.h"
|
|
#include "countdriv.h"
|
|
#include "counter.h"
|
|
#include "splitter.h"
|
|
#include "stringdict.h"
|
|
#include "HistMem.h"
|
|
#include "HistDriv.i"
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
pHistDriver CreateHistDriver(pStringDict pOption)
|
|
{
|
|
pHistDriver pNew = NULL;
|
|
char pDim[20];
|
|
int i;
|
|
|
|
/* allocate some more memory */
|
|
pNew = (pHistDriver)malloc(sizeof(HistDriver));
|
|
if(!pNew)
|
|
{
|
|
return NULL;
|
|
}
|
|
memset(pNew,0,sizeof(HistDriver));
|
|
|
|
/* initialise defaults */
|
|
pNew->eHistMode = eHNormal;
|
|
StringDictAddPair(pOption,"histmode","normal");
|
|
pNew->eFlow = eOCeil;
|
|
StringDictAddPair(pOption,"overflowmode","ceil");
|
|
pNew->iRank = 1;
|
|
StringDictAddPair(pOption,"rank","1");
|
|
pNew->iLength = 412;
|
|
StringDictAddPair(pOption,"length","412");
|
|
pNew->iBinWidth = 16;
|
|
StringDictAddPair(pOption,"binwidth","16");
|
|
for(i = 0; i < MAXDIM; i++)
|
|
{
|
|
sprintf(pDim,"dim%1.1d",i);
|
|
StringDictAddPair(pOption,pDim,"-126");
|
|
}
|
|
pNew->fCountPreset = 10.;
|
|
pNew->eCount = eTimer;
|
|
pNew->iReconfig = 1;
|
|
pNew->iUpdate = 0;
|
|
pNew->iTimeChan = 1;
|
|
|
|
|
|
return pNew;
|
|
}
|
|
/*-------------------------------------------------------------------------*/
|
|
void DeleteHistDriver(pHistDriver self)
|
|
{
|
|
assert(self);
|
|
|
|
if(self->FreePrivate)
|
|
{
|
|
self->FreePrivate(self);
|
|
}
|
|
free(self);
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
static char *pHistMode[] = {
|
|
"transparent",
|
|
"normal",
|
|
"tof",
|
|
"strobo",
|
|
"hrpt",
|
|
NULL
|
|
};
|
|
|
|
static HistMode Text2Mode(char *text)
|
|
{
|
|
int i = 0;
|
|
|
|
while(pHistMode[i] != NULL)
|
|
{
|
|
if(strcmp(pHistMode[i],text) == 0)
|
|
{
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
/* not found */
|
|
return -1;
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
static char *pFlowMode[] = {
|
|
"ignore",
|
|
"ceil",
|
|
"count",
|
|
"reflect",
|
|
NULL
|
|
};
|
|
|
|
static OverFlowMode Text2Flow(char *text)
|
|
{
|
|
int i = 0;
|
|
|
|
while(pFlowMode[i] != NULL)
|
|
{
|
|
if(strcmp(pFlowMode[i],text) == 0)
|
|
{
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
/* not found */
|
|
return -1;
|
|
}
|
|
/*------------------------------------------------------------------------*/
|
|
int HistDriverConfig(pHistDriver self, pStringDict pOpt, SConnection *pCon)
|
|
{
|
|
int iRet;
|
|
char pBueffel[512];
|
|
char pValue[80];
|
|
float fVal;
|
|
TokenList *pList = NULL, *pCurrent;
|
|
char *pBuf = NULL;
|
|
int i;
|
|
|
|
assert(self);
|
|
assert(pOpt);
|
|
assert(pCon);
|
|
|
|
/* enter histmode */
|
|
iRet = StringDictGet(pOpt,"histmode",pValue,79);
|
|
if(!iRet)
|
|
{
|
|
SCWrite(pCon,"ERROR: internal Value not found!",eError);
|
|
return 0;
|
|
}
|
|
strtolower(pValue);
|
|
iRet = Text2Mode(pValue);
|
|
if(iRet < 0)
|
|
{
|
|
sprintf(pBueffel,"ERROR: Invalid parameter %s to HistMode",pValue);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
self->eHistMode = iRet;
|
|
|
|
/* handle overflowmode */
|
|
iRet = StringDictGet(pOpt,"overflowmode",pValue,79);
|
|
if(!iRet)
|
|
{
|
|
SCWrite(pCon,"ERROR: internal Value not found!",eError);
|
|
return 0;
|
|
}
|
|
strtolower(pValue);
|
|
iRet = Text2Flow(pValue);
|
|
if(iRet < 0)
|
|
{
|
|
sprintf(pBueffel,"ERROR: Invalid parameter %s to OverflowMode",pValue);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
self->eFlow = iRet;
|
|
|
|
/* no of hist */
|
|
iRet = StringDictGetAsNumber(pOpt,"rank",&fVal);
|
|
if(!iRet)
|
|
{
|
|
iRet = StringDictGet(pOpt,"rank",pValue,79);
|
|
if(iRet)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %s not valid for Rank ",pValue);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
SCWrite(pCon,"ERROR: internal Value not found!",eError);
|
|
return 0;
|
|
}
|
|
}
|
|
if(fVal < 0)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %f is invalid for rank",fVal);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
self->iRank = (int)fVal;
|
|
|
|
/* length */
|
|
iRet = StringDictGetAsNumber(pOpt,"length",&fVal);
|
|
if(!iRet)
|
|
{
|
|
iRet = StringDictGet(pOpt,"length",pValue,79);
|
|
if(iRet)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %s not valid for Length ",pValue);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
SCWrite(pCon,"ERROR: internal Value not found!",eError);
|
|
return 0;
|
|
}
|
|
}
|
|
if(fVal < 1)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %f is invalid for Length",fVal);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
self->iLength = (int)fVal;
|
|
|
|
/* BinWidth */
|
|
iRet = StringDictGetAsNumber(pOpt,"binwidth",&fVal);
|
|
if(!iRet)
|
|
{
|
|
iRet = StringDictGet(pOpt,"binwidth",pValue,79);
|
|
if(iRet)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %s not valid for BinWidth ",pValue);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
SCWrite(pCon,"ERROR: internal Value not found!",eError);
|
|
return 0;
|
|
}
|
|
}
|
|
if(fVal < 1)
|
|
{
|
|
sprintf(pBueffel,"ERROR: %f is invalid for BinWidth",fVal);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
self->iBinWidth = (int)fVal;
|
|
|
|
/* dimensions */
|
|
self->nDim = 0;
|
|
for(i = 0; i < MAXDIM; i++)
|
|
{
|
|
sprintf(pValue,"dim%1.1d",i);
|
|
iRet = StringDictGetAsNumber(pOpt,pValue,&fVal);
|
|
if(!iRet)
|
|
{
|
|
if(i < self->iRank)
|
|
{
|
|
sprintf(pBueffel,"WARNING: dimension %s NOT found",pValue);
|
|
SCWrite(pCon,pBueffel,eWarning);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(fVal > 0.)
|
|
{
|
|
self->nDim++;
|
|
self->iDims[i] = (int)fVal;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|