WebSVN - f9daq - Rev 298 - /cvi/apps/petdaq/vmusb

#include <formatio.h>
#include "H1D.h"
#include "H2D.h"
#include <utility.h>
#include <ansi_c.h>
#include <cvirte.h>
#include <userint.h>
#include "vmusb_ctrl.h"
#include "daq_cvi.h"
static int p1, p2, p3;

static int daq_on;
static int plothandle[4]= {0,0,0, 0};
static int tfID;
static int controlID;
static int verbose;
static int timeout;
extern int ctrlcflag;

#define MAX_THREADS 10

static CmtThreadPoolHandle poolHandle = 0;

#define MAXCH 72
float gSum[6];
float gRawSum[6];
float gMax[6];
float gSumCluster[6];
float gNtdata[MAXCH*3];
int gNabove[5];
double gData[MAXCH]; // korigirani ADC ji
double gAdc[MAXCH]; // raw ADC ji

double gPedestals[MAXCH];
double gPeak[MAXCH];

double gPeakScaling;
double gThreshold;

typedef struct Channel {
int ix;
int iy;
int idx;

};

struct Channel m_geo_ch[16];

char strbuf[0xFF];

int gLog=0;
int printf(const char *format, ...) {
va_list aptr;
int ret;
FILE *flog;

va_start(aptr, format);
ret = vsprintf(strbuf, format, aptr);
va_end(aptr);
SetCtrlVal(p1,P1_IO,strbuf);

if (gLog) {
flog = fopen ("stdio.log", "a");
fprintf (flog, "%s", strbuf);
fclose (flog);
}
return(ret);
}

int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow) {
if (InitCVIRTE (hInstance, 0, 0) == 0)
return -1; /* out of memory */
if ((p1 = LoadPanel (0, "vmusb_ctrl.uir", P1)) < 0)
return -1;
if ((p2 = LoadPanel (0, "vmusb_ctrl.uir", P2)) < 0)
return -1;
if ((p3 = LoadPanel (0, "vmusb_ctrl.uir", P3)) < 0)
return -1;
SetStdioPort (CVI_STDIO_WINDOW);
SetSleepPolicy(VAL_SLEEP_MORE);
CmtNewThreadPool (MAX_THREADS, &poolHandle);
DisplayPanel (p1);

RunUserInterface ();
DiscardPanel (p1);
DiscardPanel (p2);
DiscardPanel (p3);
return 0;
}

static void start_timer (double tout) {
timeout = 0;
SetCtrlAttribute (p1, P1_TIMER, ATTR_INTERVAL, tout);
SetCtrlAttribute (p1, P1_TIMER, ATTR_ENABLED, 1);
}

static void stop_timer ( void ) {
SetCtrlAttribute (p1, P1_TIMER, ATTR_ENABLED, 0);
//DRSSetTimeout();
}

int georead(){
int i;
for (i=0; i<64; i++) {
int row=i+1;
double val;
unsigned short sval;
GetTableCellVal (p3, P3_CGEO, MakePoint (3,row), &sval);
fThreshold[i]=sval;
GetTableCellVal (p3, P3_CGEO, MakePoint (4,row), &val);
gPeak[i]=val;
GetTableCellVal (p3, P3_CGEO, MakePoint (5,row), &val);
gPedestals[i]=val;
}

GetCtrlVal(p3, P3_PEAKSCALING, &gPeakScaling );
GetCtrlVal(p3, P3_GTHRESHOLD, &gThreshold );

for (i=0; i<16; i++) {
int row=i+1;
double val;
unsigned short sval, id;
GetTableCellVal (p3, P3_CGEO, MakePoint (1,row), &id);
GetTableCellVal (p3, P3_CGEO, MakePoint (2,row), &sval);
m_geo_ch[id].ix=sval;
GetTableCellVal (p3, P3_CGEO, MakePoint (3,row), &sval);
m_geo_ch[id].iy=sval;
m_geo_ch[id].idx=id;
}

return 0;
}

void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,
CmtThreadFunctionID functionID, unsigned int event,
int value, void *callbackData ) {

daq_on=0;
//SetDimming(0);
printf("End of Thread \n");
return ;

}

int CVICALLBACK RefreshGraphs (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_TIMER_TICK:
// if (!daq_on ) return 0;
case EVENT_COMMIT: {

int ch=0;
int logy=0;
int pmt =0;
int updateplots=0;
GetCtrlVal(p1,P1_RECO, &updateplots);
if (!updateplots) return 0;
GetCtrlVal(p2,P2_PMT, &pmt);
GetCtrlVal(p2,P2_ADC, &ch);

H1D_Draw(10,p2,P2_GRAPHADC,&plothandle[1]);
H2D_Draw(0,p2,P2_GRAPH2D,&plothandle[2]);

}

break;

}
return 0;
}

int vmusb_init(){

int range = 2056;
for (int i=0; i<MAXCH; i++) {
char name[0xFF];
sprintf(name,"adc%d", i);

H1D_Init(i, name,name, range, 0 , range);
H1D_SetTitleX(0,"ADC");
H1D_SetTitleY(0,"N");
sprintf(name,"adc%d", i);

sprintf(name,"energy%d", i);
H1D_Init(100+i, name,name, range, 0 , range);
H1D_SetTitleX(0,"Energy");
H1D_SetTitleY(0,"N");
}

H2D_Init(0, "cog","Center of grg_peakscalingavity", 256, 0 ,1, 256, 0 ,1);
H2D_SetTitleX(0,"x");
H2D_SetTitleY(0,"y");

return 0;
}

double GetEnergy(int ch, int adc){
return (adc-gPedestals[ch])/(gPeak[ch]-gPedestals[ch])*gPeakScaling;
}

int FillHistograms() {

int npmts = 4;
for (int ipmt=0; ipmt<npmts; ipmt++) { // zanka preko pmtjev
int j2= (ipmt/2)*2+1-ipmt%2; // sosednja fotopomnozevalka

float posx[2]= {0,0};
float posy[2]= {0,0};
float sum[2]= {0,0};
float m_threshold =100;
for (int ich=0; ich<16; ich++) { // zanka preko elektronskih kanalov na fotopomnozevalki
int ch= ich+ipmt*16;
if (gMax[ipmt]>m_threshold) {
posx[0]+= gData[ch]*m_geo_ch[ich].ix;
posy[0]+= gData[ch]*m_geo_ch[ich].iy;
sum[0] += gData[ch];

if (gData[ch]> 0.2*gMax[ipmt]) { // pri racunanju pozicije upostevaj le kanale, ki imajo vrednost vecjo od ratio*maksimalna na tisti fotopomnozevalki
posx[1]+= gData[ch]*m_geo_ch[ich].ix;
posy[1]+= gData[ch]*m_geo_ch[ich].iy;
sum[1] += gData[ch];
}
}
}

if ( sum[0] > 0 ) {
float px=posx[0]/sum[0];
float py=posy[0]/sum[0];
H2D_Fill(0, px,py,1);
}
}

return 0;
};

int DecodeData(int n, unsigned int *buf){

int idx=1;
int neve=buf[0]/2;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
for (int nev=0;nev<neve;nev++){
int len=buf[idx];
int sb =buf[idx+1];
unsigned int *pbuf=&buf[idx+2];
if (sb!=0xffab) {
printf("0x%04x!0xffab len=%d\n",sb,len);
break;
}
// postavi na nic
#define InitArrayWithAValue(arr,n,x) {for (int i=0;i<n;i++) arr[i]=x;}
InitArrayWithAValue( gSum , 4 , 0);
InitArrayWithAValue( gRawSum , 4 , 0);
InitArrayWithAValue( gMax , 4 , 0);
InitArrayWithAValue( gSumCluster, 4 , 0);
InitArrayWithAValue( gNabove , 4 , 0);
InitArrayWithAValue( gData , MAXCH, 0);
InitArrayWithAValue( gAdc , MAXCH, 0);
//------------------------------------------------------------
for (int i0=0;i0<len-2;i0+=2) {

int data0 = pbuf[i0];
int data1 = pbuf[i0+1];
int geo = (data1 >> 11) & 0x1f;
int ch = (data1&0x1f) | (geo<<5);
int dtype = (data1>>9)&0x3;
int adc = data0&0xfff;

switch (dtype) {
case 0x0:
if (ch<MAXCH) {
H1D_Fill(ch,adc,1);

int ipmt = ch/16;

gAdc[ch]=adc;
gRawSum[ipmt]+=adc;

if (ch<64) gData[ch]= GetEnergy(ch,adc); else gData[ch]=adc;
H1D_Fill(1+ch,gData[ch],1);
gSum[ipmt]+=gData[ch];
if (gData[ch] >gMax[ipmt] ) gMax[ipmt]= gData[ch];
if (gData[ch] >gThreshold ) gNabove[ipmt]++;
}
break;
case 0x10:
case 0x11:
case 0x01:
break;
}

};// for (int i0=0;i0<len-2;i0+=2)
//------------------------------------------------------------

idx+=len+1;
FillHistograms();
} // for (int nev=0;nev<neve;nev++)
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

return 0;
}
int vmusb_daq(){

vmusb_init();

// print welcome message
time_t t,told=0, tstart, tstop;
time(&t);
printf("#############################################\n");
printf("Program vmusb version\n");
printf("Compiled on %s %s\n",__DATE__, __TIME__);
printf("Runtime %s \n",ctime(&t));
printf("#############################################\n");

int neve=-1;
char cfname[100]="test.dat";
char fname[0xff];
char fpedname[0xff];

#define BSIZE 10000
uint32_t data[10000];
int oldValue;
//oldValue = SetBreakOnLibraryErrors (0);
daq_init(); /* Function calls that may legitimately return errors. */
//SetBreakOnLibraryErrors (oldValue);

int output=0;
GetCtrlVal(p1,P1_OUTPUT, &output);

GetCtrlVal(p1,P1_FMASK, fpedname);
int fsize=0;
georead();

GetCtrlVal(p1,P1_NEVE, &neve);
// negative argument time ( in s )limited event loop
GetCtrlVal(p1,P1_FNAME, fname);

if (GetFileInfo(fname,&fsize)==1) {
printf("Error !\n");
printf( "File %s already exist. Appending ....\n",fname);
//fprintf(stdout,"Remove the file and restart !!!\n");
//exit(0);
}

FILE *fp=NULL;
if (output) fp = fopen(fname,"a");
//gzFile fp=gzopen(fname,"a");

init();
clear();

int hdr[4]={2}; // recid od run 11 naprej
int i=0;
int ntotal=0;
int counters[30]={0,0,0,0,0, 0,0,0,0,0,0,0};
char names[10][20]={"TRG","CAEN V965"};
time(&t);
tstart=t;
tstop=tstart+360000;
int evetype=0;
GetCtrlVal(p1,P1_EVE, &evetype);
if (evetype) {
double ntime=0;
GetCtrlVal(p1,P1_NTIME, &ntime);
tstop=tstart+ntime;
neve=-1;
}
int reco=0;
GetCtrlVal(p1,P1_RECO, &reco);
for (i=0;i!=neve && !ctrlcflag && t<tstop;i++){
time(&t);
if (t!=told ) {
printf("%d in %2.2f min daq::event() %s\n",i, (double)(t-tstart)/60., ctime(&t));
GetCtrlVal(p1,P1_RECO, &reco);
RefreshGraphs(p2,P2_PMT,EVENT_COMMIT,NULL,0,0);
}
int nb=event(data,BSIZE, counters,t!=told);
SetCtrlVal(p1,P1_CEVE,i);
if (nb>0){

if (reco) DecodeData(nb, data);
// zapis v datoteko
hdr[1]=nb+4*sizeof(int);
hdr[2]=time(NULL);
hdr[3]=i;
if (fp) fwrite(hdr, sizeof(int),4 , fp);
if (fp) ntotal += fwrite(data, 1,nb, fp);

} else i--;
told=t;
}

end();

printf("Number of Events: %d\n",i);
if (ctrlcflag) printf("User Program termination CTRL-C\n");
if (t>tstop ) printf("Timeout termination tstart# t>tstop: %d# %d >%d\n",(int)t, (int)tstart, (int) tstop);

if (fp) fclose(fp);
//gzclose(fp);
printf("%d bytes written to %s\nCounts:\n", (int) (ntotal*sizeof(int)),fname);
for (i=0;i<2;i++) printf("%s\t%d\t%d\n",names[i],counters[2*i],counters[2*i+1]) ;

printf("Usage: vmusb [filename] [number of events] [thresholdfile]\n negative number of events = acq time in seconds\n");

disconnect();

return 0;
}

int CVICALLBACK StartCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
ThreadFunctionPtr mythread = NULL;
switch (event) {

case EVENT_COMMIT:

controlID= control;
if (panel == p1 && control == P1_START) {
mythread = vmusb_daq;

}
//if (panel == xyscan && control == SCAN_SCAN) mythread = scan;
if (mythread!=NULL) {
printf("New Thread panel=%d button=%d\n", panel, control);

// SetDimming(1);

CmtScheduleThreadPoolFunctionAdv (poolHandle, mythread, &controlID,
DEFAULT_THREAD_PRIORITY,
EndOfThread,
EVENT_TP_THREAD_FUNCTION_END,
NULL, RUN_IN_SCHEDULED_THREAD,
&tfID);
}
break;
}
return 0;
}

int CVICALLBACK StopCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
ctrlcflag=1;
break;
}
return 0;
}

int CVICALLBACK ExitCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
QuitUserInterface (0);
break;
}
return 0;
}

int CVICALLBACK ShowHistoCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
DisplayPanel (p2);
break;
}
return 0;
}

int CVICALLBACK SetLogZCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
GetCtrlVal(panel,control, &log);

if (log) {
SetCtrlAttribute (p2, P2_GRAPH2D, ATTR_YMAP_MODE, VAL_LOG);

} else {
SetCtrlAttribute (p2, P2_GRAPH2D, ATTR_YMAP_MODE, VAL_LINEAR);
}

break;
}
return 0;
}

int CVICALLBACK SetLogYCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {

switch (event) {
case EVENT_COMMIT:{
int log=0;
GetCtrlVal(panel,control, &log);

if (log) {
SetCtrlAttribute (p2, P2_GRAPHADC, ATTR_YMAP_MODE, VAL_LOG);

} else {
SetCtrlAttribute (p2, P2_GRAPHADC, ATTR_YMAP_MODE, VAL_LINEAR);
}

}
break;
}
return 0;
}

int CVICALLBACK ShowMainCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
DisplayPanel (p1);
break;
}
return 0;
}

int CVICALLBACK ShowSettingsCB (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2) {
switch (event) {
case EVENT_COMMIT:
DisplayPanel (p3);
break;
}
return 0;
}

Subversion Repositories f9daq

(root)/cvi/apps/petdaq/vmusb_ctrl.c - Rev 298