sics/mcstashm.c

/*--------------------------------------------------------------------------
  This is a driver for a histogram memory which is meant to interoperate
  with a McStas simulation. For reasons of lazyness the control of counting
  operations is delegated to a single counter object and this driver only
  provides data space and means to access and copy data. This driver also
  works without a counter connected in order to support multi HM control via
  the hmcontrol module. 
  
  copyright: see file COPYRIGHT
  
  Mark Koennecke, June 2005
  -------------------------------------------------------------------------*/
#include <stdlib.h>
#include <assert.h>
#include "sics.h"
#include "counter.h"
#include "stringdict.h"
#include "HistDriv.i"
/*================= operator functions ====================================*/
static int McHMConfigure(pHistDriver self, SConnection *pCon,
						pStringDict pOpt, SicsInterp *pSics){
	char counterName[80];
	char pError[256];
	
	if(StringDictGet(pOpt,"counter",counterName,79) == 1){
		self->pPriv = FindCommandData(pSics,counterName,"SingleCounter");
		if(self->pPriv == NULL){
			snprintf(pError,255,
				"ERROR: tried to configure counter but %s not found",
				counterName);
			SCWrite(pCon,pError,eError);
			return 0;				
		}
	}
	self->iReconfig = 0;
	return configureHMdata(self->data,pOpt,pCon);
}
/*-------------------------------------------------------------------------*/
static int McHMStart(pHistDriver self, SConnection *pCon){
	pCounter pCount = NULL;
	
	/*
	 * clear data
	 */
	 clearHMData(self->data);
	/*
	 * if there is a counter, make him start
	 */
	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	pCount->pDriv->eMode = self->eCount;
	 	pCount->pDriv->fPreset = self->fCountPreset;
	 	return pCount->pCountInt->StartCount(pCount,pCon);
	 } else {
	 	return 1;
	 }
}
/*------------------------------------------------------------------------*/
static int McHMHalt(pHistDriver self){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return pCount->pCountInt->Halt(pCount);
	 } else {
	 	return 1;
	 }
}
/*-------------------------------------------------------------------------*/
static int McHMCountStatus(pHistDriver self, SConnection *pCon){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return pCount->pCountInt->CheckCountStatus(pCount,pCon);
	 } else {
	 	return HWIdle;
	 }
}
/*------------------------------------------------------------------------*/
static int McHMGetError(pHistDriver self, int *iCode, char *error, int errLen){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return pCount->pDriv->GetError(pCount->pDriv,iCode, error, errLen);
	 } else {
	 	*iCode = -1000;
	 	strncpy(error,"Feature not implemented in McStasHM",errLen);
	 	return 1;
	 }
}
/*-------------------------------------------------------------------------*/
static int McHMFixIt(pHistDriver self, int iCode){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return pCount->pDriv->TryAndFixIt(pCount->pDriv,iCode);
	 } else {
		return COTERM;		
	 }
}
/*-----------------------------------------------------------------------*/
static int McHMGetData(pHistDriver self, SConnection *pCon){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return pCount->pCountInt->TransferData(pCount,pCon);
	 } else {
		return 1;		
	 }
}
/*-----------------------------------------------------------------------*/
static int McHMGetHistogram(pHistDriver self, SConnection *pCon,
			    int bank, int start, int end, HistInt *pData){
  /*
   * make sure data gets transferred
   */
  return McHMGetData(self,pCon);
}
/*-------------------------------------------------------------------------*/
static int McHMSetHistogram(pHistDriver self, SConnection *pCon,
				            int bank, int start, int end, 
				            HistInt *pData){
	int i, count = 0;
	HistInt *hmData;
	
	assert(bank == 0);

	hmData = self->data->localBuffer;
	for(i = start; i <  end; i++, count++){
		hmData[i] = pData[count];
	}
	return 1;						            	
}			
/*-------------------------------------------------------------------------*/
static long McHMMonitor(pHistDriver self, int i, SConnection *pCon){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return GetMonitor(pCount,i,pCon);
	 } else {
		return 0L;		
	 }
}
/*-------------------------------------------------------------------------*/
static float McHMGetTime(pHistDriver self, SConnection *pCon){
	pCounter pCount = NULL;

	 pCount = (pCounter)self->pPriv;
	 if(pCount != NULL){
	 	return GetCountTime(pCount,pCon);;
	 } else {
		return -999.99;		
	 }
}
/*--------------------------------------------------------------------------*/
static int McHMPreset(pHistDriver self, SConnection *pCon, HistInt val){
	int i;
	long length;
	HistInt *data;
	
	length = getHMDataLength(self->data);
	data = self->data->localBuffer;
	for(i = 0; i < length; i++){
		data[i] = val;
	}
	return 1;
}		     
/*------------------------------------------------------------------------*/
static int McHMPause(pHistDriver self, SConnection *pCon){
	return HWFault;
}       	
/*-----------------------------------------------------------------------*/
static int McHMContinue(pHistDriver self, SConnection *pCon){
	return HWFault;
}
/*========================== the actual creation function ================*/
pHistDriver NewMcStasHM(pStringDict pOpt){
	pHistDriver pNew = NULL;
	
	pNew = CreateHistDriver(pOpt);
	if(pNew == NULL){
		return NULL;
	}
    pNew->Configure = McHMConfigure;
    pNew->Start     = McHMStart;
    pNew->Halt      = McHMHalt;
    pNew->GetCountStatus = McHMCountStatus;
    pNew->GetError  = McHMGetError;
    pNew->TryAndFixIt = McHMFixIt;
    pNew->GetData   = McHMGetData;
    pNew->GetHistogram =  McHMGetHistogram;
    pNew->SetHistogram =  McHMSetHistogram;
    pNew->GetMonitor   =  McHMMonitor;
    pNew->GetTime      =  McHMGetTime;
    pNew->Preset       =  McHMPreset;
    pNew->FreePrivate  =  NULL;
    pNew->Pause        =  McHMPause;
    pNew->Continue     =  McHMContinue;
    StringDictAddPair(pOpt,"counter","UNKNOWN");
	StringDictUpdate(pOpt,"update","10");
	
    return pNew;
}