source: sans/Dev/trunk/NCNR_User_Procedures/Reduction/SANS/EventModeProcessing.ipf @ 875

Last change on this file since 875 was 875, checked in by srkline, 10 years ago

More changes to the event mode processing, updating the panel and adding some methods for removing misencoded time point

  1. Ready for some more testing to figure out what is good and what is bad.

Added some more values in to the SASCALC for the 10m instrument (still hidden)

File size: 41.9 KB
Line 
1#pragma rtGlobals=1             // Use modern global access method.
2#pragma IgorVersion=6.1
3
4//#include "TISANE"
5
6
7// TODO:
8//
9// -- fix the log/lin display - it's not working correctly
10// X- add controls to show the bar graph
11// x- add popup for selecting the binning type
12// x- add ability to save the slices to RAW VAX files
13// X- add control to show the bin counts and bin end times
14// x- ADD buttons, switches, etc for the oscillatory mode - so that this can be accessed
15//
16// x- How are the headers filled for the VAX files from Teabag???
17// -- I currently read the events 2x. Once to count the events to make the waves the proper
18//     size, then a second time to actualy process the events. Would it be faster to insert points
19//     as needed, or to estimate the size, and make it too large, then trim at the end...
20// ((( NO -- deleting the extra zeros at the end is WAY WAY slower - turns 2sec into 100 sec)))
21//
22//
23//
24// -- for the 19 MB file - the max time is reported as 67.108s, but the max rescaled time = 61 s
25//    based on the last point... there are "spikes" in the time! -- look at the plot in the
26//    data browser... (so waveMax() gives a different answer than the end point, and BinarySearch()
27//    doesn't have a monotonic file to work with... ugh.)
28//
29//
30//
31// differentiate may be useful at some point, but not sure
32//¥Differentiate rescaledTime/D=rescaledTime_DIF
33//¥Display rescaledTime,rescaledTime_DIF
34//
35//
36
37Proc Show_Event_Panel()
38        DoWindow/F EventModePanel
39        if(V_flag ==0)
40                Init_Event()
41                EventModePanel()
42        EndIf
43End
44
45
46Function Init_Event()
47        String/G        root:Packages:NIST:gEvent_logfile
48        String/G        root:Packages:NIST:gEventDisplayString="Details of the file load"
49       
50        Variable/G      root:Packages:NIST:AIMTYPE_XY=0 // XY Event
51        Variable/G      root:Packages:NIST:AIMTYPE_XYM=2 // XY Minor event
52        Variable/G      root:Packages:NIST:AIMTYPE_MIR=1 // Minor rollover event
53        Variable/G      root:Packages:NIST:AIMTYPE_MAR=3 // Major rollover event
54
55        Variable/G root:Packages:NIST:gEvent_time_msw = 0
56        Variable/G root:Packages:NIST:gEvent_time_lsw = 0
57        Variable/G root:Packages:NIST:gEvent_t_longest = 0
58
59        Variable/G root:Packages:NIST:gEvent_tsdisp //Displayed slice
60        Variable/G root:Packages:NIST:gEvent_nslices = 10  //Number of time slices
61        Variable/G root:Packages:NIST:gEvent_slicewidth  = 1000 // slice width (us)
62       
63        Variable/G root:Packages:NIST:gEvent_prescan // Do we prescan the file?
64        Variable/G root:Packages:NIST:gEvent_logint = 1
65
66        Variable/G root:Packages:NIST:gEvent_Mode = 0           // ==0 for "stream", ==1 for Oscillatory
67        Variable/G root:Packages:NIST:gRemoveBadEvents = 1              // ==1 to remove "bad" events, ==0 to read "as-is"
68
69        NVAR nslices = root:Packages:NIST:gEvent_nslices
70       
71        SetDataFolder root:
72        NewDataFolder/O/S root:Packages:NIST:Event
73       
74        Make/D/O/N=(XBINS,YBINS,nslices) slicedData
75        Duplicate/O slicedData logslicedData
76        Duplicate/O slicedData dispsliceData
77       
78        SetDataFolder root:
79End
80
81Proc EventModePanel()
82        PauseUpdate; Silent 1           // building window...
83        NewPanel /W=(100,50,600,840)/N=EventModePanel/K=2
84        DoWindow/C EventModePanel
85        ModifyPanel fixedSize=1,noEdit =1
86        //ShowTools/A
87        SetDrawLayer UserBack
88        Button button0,pos={10,10}, size={150,20},title="Load Event Log File",fSize=12
89        Button button0,proc=LoadEventLog_Button
90       
91        TitleBox tb1,pos={20,650},size={460,80},fSize=12
92        TitleBox tb1,variable=root:Packages:NIST:gEventDisplayString
93       
94        CheckBox chkbox1,pos={170,8},title="Oscillatory Mode?"
95        CheckBox chkbox1,variable = root:Packages:NIST:gEvent_mode
96        CheckBox chkbox3,pos={170,27},title="Remove Bad Events?"
97        CheckBox chkbox3,variable = root:Packages:NIST:gRemoveBadEvents
98       
99        Button doneButton,pos={435,12}, size={50,20},title="Done",fSize=12
100        Button doneButton,proc=EventDone_Proc
101
102        Button button2,pos={20,122},size={140,20},proc=ShowEventDataButtonProc,title="Show Event Data"
103        Button button3,pos={20,147},size={140,20},proc=ShowBinDetailsButtonProc,title="Show Bin Details"
104        Button button4,pos={175,122},size={140,20},proc=UndoTimeSortButtonProc,title="Undo Time Sort"
105        Button button5,pos={175,147},size={140,20},proc=ExportSlicesButtonProc,title="Export Slices as VAX"
106        Button button6,pos={378,13},size={40,20},proc=EventModeHelpButtonProc,title="?"
107       
108        //DrawLine 10,35,490,35
109        Button button1,pos = {10,50}, size={150,20},title="Process Data",fSize=12
110        Button button1,proc=ProcessEventLog_Button
111        SetVariable setvar1,pos={170,50},size={160,20},title="Number of slices",fSize=12
112        SetVariable setvar1,value=root:Packages:NIST:gEvent_nslices
113        SetVariable setvar2,pos={330,50},size={160,20},title="Max Time (s)",fSize=12
114        SetVariable setvar2,value=root:Packages:NIST:gEvent_t_longest
115        //DrawLine 10,65,490,65
116       
117//      PopupMenu popup0 title="Bin Spacing",pos={150,90},value="Equal;Fibonacci;Log;"
118        PopupMenu popup0 title="Bin Spacing",pos={150,90},value="Equal;Fibonacci;"
119       
120        CheckBox chkbox2,pos={20,95},title="Log Intensity",value=1
121        CheckBox chkbox2,variable=root:Packages:NIST:gEvent_logint,proc=LogIntEvent_Proc
122        SetVariable setvar0,pos={320,90},size={160,20},title="Display Time Slice",fSize=12
123        SetVariable setvar0,value= root:Packages:NIST:gEvent_tsdisp
124        SetVariable setvar0,proc=sliceSelectEvent_Proc
125        Display/W=(20,180,480,640)/HOST=EventModePanel/N=Event_slicegraph
126        AppendImage/W=EventModePanel#Event_slicegraph/T root:Packages:NIST:Event:dispsliceData
127        ModifyImage/W=EventModePanel#Event_slicegraph  ''#0 ctab= {*,*,ColdWarm,0}
128        ModifyImage/W=EventModePanel#Event_slicegraph ''#0 ctabAutoscale=3
129        ModifyGraph margin(left)=14,margin(bottom)=14,margin(top)=14,margin(right)=14
130        ModifyGraph mirror=2
131        ModifyGraph nticks=4
132        ModifyGraph minor=1
133        ModifyGraph fSize=9
134        ModifyGraph standoff=0
135        ModifyGraph tkLblRot(left)=90
136        ModifyGraph btLen=3
137        ModifyGraph tlOffset=-2
138        SetAxis/A left
139        SetActiveSubwindow ##
140EndMacro
141
142Function ShowEventDataButtonProc(ba) : ButtonControl
143        STRUCT WMButtonAction &ba
144
145        switch( ba.eventCode )
146                case 2: // mouse up
147                        // click code here
148                        Execute "ShowRescaledTimeGraph()"
149                        //
150                        DifferentiatedTime()
151                        //
152                        break
153                case -1: // control being killed
154                        break
155        endswitch
156
157        return 0
158End
159
160Function ShowBinDetailsButtonProc(ba) : ButtonControl
161        STRUCT WMButtonAction &ba
162
163        switch( ba.eventCode )
164                case 2: // mouse up
165                        // click code here
166                        Execute "ShowBinTable()"
167                        Execute "BinEventBarGraph()"
168                        break
169                case -1: // control being killed
170                        break
171        endswitch
172
173        return 0
174End
175
176Function UndoTimeSortButtonProc(ba) : ButtonControl
177        STRUCT WMButtonAction &ba
178
179        switch( ba.eventCode )
180                case 2: // mouse up
181                        // click code here
182                        Execute "UndoTheSorting()"
183                        break
184                case -1: // control being killed
185                        break
186        endswitch
187
188        return 0
189End
190
191Function ExportSlicesButtonProc(ba) : ButtonControl
192        STRUCT WMButtonAction &ba
193
194        switch( ba.eventCode )
195                case 2: // mouse up
196                        // click code here
197                        Execute "ExportSlicesAsVAX()"           //will invoke the dialog
198                        break
199                case -1: // control being killed
200                        break
201        endswitch
202
203        return 0
204End
205
206Function EventModeHelpButtonProc(ba) : ButtonControl
207        STRUCT WMButtonAction &ba
208
209        switch( ba.eventCode )
210                case 2: // mouse up
211                        // click code here
212                        DoAlert 0,"The help file has not been written yet"
213                        break
214                case -1: // control being killed
215                        break
216        endswitch
217
218        return 0
219End
220
221
222Function EventDone_Proc(ba) : ButtonControl
223        STRUCT WMButtonAction &ba
224       
225        String win = ba.win
226        switch (ba.eventCode)
227                case 2:
228                        DoWindow/K EventModePanel
229                        break
230        endswitch
231        return(0)
232End
233
234
235
236Function ProcessEventLog_Button(ctrlName) : ButtonControl
237        String ctrlName
238       
239        NVAR mode=root:Packages:NIST:gEvent_Mode
240       
241        if(mode == 0)
242                Stream_ProcessEventLog("")
243        endif
244       
245        if(mode == 1)
246                Osc_ProcessEventLog("")
247        endif
248       
249        return(0)
250end
251
252// for oscillatory mode
253//
254Function Osc_ProcessEventLog(ctrlName)
255        String ctrlName
256
257
258        Make/O/D/N=(128,128) root:Packages:NIST:Event:binnedData
259       
260        Wave binnedData = root:Packages:NIST:Event:binnedData
261        Wave xLoc = root:Packages:NIST:Event:xLoc
262        Wave yLoc = root:Packages:NIST:Event:yLoc
263
264        SetDataFolder root:Packages:NIST:Event
265        IndexForHistogram(xLoc,yLoc,binnedData)
266        SetDataFolder root:
267        Wave index = root:Packages:NIST:Event:SavedIndex
268       
269        JointHistogram(xLoc,yLoc,binnedData,index)              // puts everything into one array
270
271
272// now with the number of slices and max time, process the events
273        Osc_ProcessEvents(xLoc,yLoc,index)
274
275
276        SetDataFolder root:Packages:NIST:Event:
277
278        SetDataFolder root:
279
280        return(0)
281End
282
283
284Function Stream_ProcessEventLog(ctrlName)
285        String ctrlName
286
287//      NVAR slicewidth = root:Packages:NIST:gTISANE_slicewidth
288
289       
290        Make/O/D/N=(128,128) root:Packages:NIST:Event:binnedData
291       
292        Wave binnedData = root:Packages:NIST:Event:binnedData
293        Wave xLoc = root:Packages:NIST:Event:xLoc
294        Wave yLoc = root:Packages:NIST:Event:yLoc
295
296        SetDataFolder root:Packages:NIST:Event
297        IndexForHistogram(xLoc,yLoc,binnedData)
298        SetDataFolder root:
299        Wave index = root:Packages:NIST:Event:SavedIndex
300       
301        JointHistogram(xLoc,yLoc,binnedData,index)              // puts everything into one array
302
303
304// now with the number of slices and max time, process the events
305        Stream_ProcessEvents(xLoc,yLoc,index)
306
307
308        SetDataFolder root:Packages:NIST:Event:
309
310        SetDataFolder root:
311
312        return(0)
313End
314
315
316Proc    UndoTheSorting()
317        Osc_UndoSort()
318End
319
320// for oscillatory mode
321//
322// -- this takes the previously generated index, and un-sorts the data to restore to the
323// "as-collected" state
324//
325Function Osc_UndoSort()
326
327        SetDataFolder root:Packages:NIST:Event          //don't count on the folder remaining here
328        Wave rescaledTime = rescaledTime
329        Wave OscSortIndex = OscSortIndex
330        Wave yLoc = yLoc
331        Wave xLoc = xLoc
332        Wave timePt = timePt
333
334        Sort OscSortIndex OscSortIndex,yLoc,xLoc,timePt,rescaledTime
335
336        KillWaves/Z OscSortIndex
337       
338        SetDataFolder root:
339        return(0)
340End
341
342// for oscillatory mode
343//
344//// use indexSort to be able to restore the original data
345//¥Duplicate rescaledTime OscSortIndex
346//¥MakeIndex rescaledTime OscSortIndex
347//¥IndexSort OscSortIndex, yLoc,xLoc,timePt,rescaledTime
348//¥Sort OscSortIndex OscSortIndex,yLoc,xLoc,timePt,rescaledTime
349//
350// sort the data by time, then do the binning
351// save an index to be able to "undo" the sorting
352//
353Function Osc_ProcessEvents(xLoc,yLoc,index)
354        Wave xLoc,yLoc,index
355       
356        NVAR t_longest = root:Packages:NIST:gEvent_t_longest
357        NVAR nslices = root:Packages:NIST:gEvent_nslices
358
359        SetDataFolder root:Packages:NIST:Event          //don't count on the folder remaining here
360       
361        Make/D/O/N=(XBINS,YBINS,nslices) slicedData
362               
363        Wave slicedData = slicedData
364        Wave rescaledTime = rescaledTime
365        Wave timePt = timePt
366        Make/O/D/N=(128,128) tmpData
367        Make/O/D/N=(nslices+1) binEndTime,binCount
368        Wave binEndTime = binEndTime
369        Wave binCount = binCount
370
371        variable ii,del,p1,p2,t1,t2
372        del = t_longest/nslices
373
374        slicedData = 0
375        binEndTime[0]=0
376        BinCount[nslices]=0
377
378
379        String binTypeStr=""
380        ControlInfo /W=EventModePanel popup0
381        binTypeStr = S_value
382       
383        strswitch(binTypeStr)   // string switch
384                case "Equal":           // execute if case matches expression
385                        SetLinearBins(binEndTime,nslices,t_longest)
386                        break                                           // exit from switch
387                case "Fibonacci":               // execute if case matches expression
388                        SetFibonacciBins(binEndTime,nslices,t_longest)
389                        break
390                case "Log":             // execute if case matches expression
391                        SetLogBins(binEndTime,nslices,t_longest)
392                        break
393                default:                                                        // optional default expression executed
394                        DoAlert 0,"No match for bin type, Equal bins used"
395                        SetLinearBins(binEndTime,nslices,t_longest)
396        endswitch
397
398
399// now before binning, sort the data
400
401        //this is slow - undoing the sorting and starting over, but if you don't,
402        // you'll never be able to undo the sort
403        //
404        SetDataFolder root:Packages:NIST:Event:
405
406        if(WaveExists($"root:Packages:NIST:Event:OscSortIndex") == 0 )
407                Duplicate/O rescaledTime OscSortIndex
408                MakeIndex rescaledTime OscSortIndex
409                IndexSort OscSortIndex, yLoc,xLoc,timePt,rescaledTime   
410        Endif
411       
412        for(ii=0;ii<nslices;ii+=1)
413                if(ii==0)
414//                      t1 = ii*del
415//                      t2 = (ii+1)*del
416                        p1 = BinarySearch(rescaledTime,0)
417                        p2 = BinarySearch(rescaledTime,binEndTime[ii+1])
418                else
419//                      t2 = (ii+1)*del
420                        p1 = p2+1               //one more than the old one
421                        p2 = BinarySearch(rescaledTime,binEndTime[ii+1])               
422                endif
423
424        // typically zero will never be a valid time value in oscillatory mode. in "stream" mode, the first is normalized to == 0
425        // but not here - times are what they are.
426                if(p1 == -1)
427                        Printf "p1 = -1 Binary search off the end %15.10g <?? %15.10g\r", 0, rescaledTime[0]
428                        p1 = 0          //set to the first point if it's off the end
429                Endif
430               
431                if(p2 == -2)
432                        Printf "p2 = -2 Binary search off the end %15.10g >?? %15.10g\r", binEndTime[ii+1], rescaledTime[numpnts(rescaledTime)-1]
433                        p2 = numpnts(rescaledTime)-1            //set to the last point if it's off the end
434                Endif
435                Print p1,p2
436
437
438                tmpData=0
439                JointHistogramWithRange(xLoc,yLoc,tmpData,index,p1,p2)
440                slicedData[][][ii] = tmpData[p][q]
441               
442//              binEndTime[ii+1] = t2
443                binCount[ii] = sum(tmpData,-inf,inf)
444        endfor
445
446        Duplicate/O slicedData,root:Packages:NIST:Event:dispsliceData,root:Packages:NIST:Event:logSlicedData
447        Wave logSlicedData = root:Packages:NIST:Event:logSlicedData
448        logslicedData = log(slicedData)
449
450        SetDataFolder root:
451        return(0)
452End
453
454
455// for the mode of "one continuous exposure"
456//
457Function Stream_ProcessEvents(xLoc,yLoc,index)
458        Wave xLoc,yLoc,index
459       
460        NVAR t_longest = root:Packages:NIST:gEvent_t_longest
461        NVAR nslices = root:Packages:NIST:gEvent_nslices
462
463        SetDataFolder root:Packages:NIST:Event          //don't count on the folder remaining here
464       
465        Make/D/O/N=(XBINS,YBINS,nslices) slicedData
466               
467        Wave slicedData = slicedData
468        Wave rescaledTime = rescaledTime
469        Make/O/D/N=(128,128) tmpData
470        Make/O/D/N=(nslices+1) binEndTime,binCount//,binStartTime
471        Wave binEndTime = binEndTime
472//      Wave binStartTime = binStartTime
473        Wave binCount = binCount
474
475        variable ii,del,p1,p2,t1,t2
476        del = t_longest/nslices
477
478        slicedData = 0
479        binEndTime[0]=0
480        BinCount[nslices]=0
481       
482        String binTypeStr=""
483        ControlInfo /W=EventModePanel popup0
484        binTypeStr = S_value
485       
486        strswitch(binTypeStr)   // string switch
487                case "Equal":           // execute if case matches expression
488                        SetLinearBins(binEndTime,nslices,t_longest)
489                        break                                           // exit from switch
490                case "Fibonacci":               // execute if case matches expression
491                        SetFibonacciBins(binEndTime,nslices,t_longest)
492                        break
493                case "Log":             // execute if case matches expression
494                        SetLogBins(binEndTime,nslices,t_longest)
495                        break
496                default:                                                        // optional default expression executed
497                        DoAlert 0,"No match for bin type, Equal bins used"
498                        SetLinearBins(binEndTime,nslices,t_longest)
499        endswitch
500       
501        for(ii=0;ii<nslices;ii+=1)
502                if(ii==0)
503//                      t1 = ii*del
504//                      t2 = (ii+1)*del
505                        p1 = BinarySearch(rescaledTime,0)
506                        p2 = BinarySearch(rescaledTime,binEndTime[ii+1])
507                else
508//                      t2 = (ii+1)*del
509                        p1 = p2+1               //one more than the old one
510                        p2 = BinarySearch(rescaledTime,binEndTime[ii+1])               
511                endif
512
513                if(p1 == -1)
514                        Printf "p1 = -1 Binary search off the end %15.10g <?? %15.10g\r", 0, rescaledTime[0]
515                        p1 = 0          //set to the first point if it's off the end
516                Endif
517                if(p2 == -2)
518                        Printf "p2 = -2 Binary search off the end %15.10g >?? %15.10g\r", binEndTime[ii+1], rescaledTime[numpnts(rescaledTime)-1]
519                        p2 = numpnts(rescaledTime)-1            //set to the last point if it's off the end
520                Endif
521                Print p1,p2
522
523
524                tmpData=0
525                JointHistogramWithRange(xLoc,yLoc,tmpData,index,p1,p2)
526                slicedData[][][ii] = tmpData[p][q]
527               
528//              binEndTime[ii+1] = t2
529                binCount[ii] = sum(tmpData,-inf,inf)
530        endfor
531
532        Duplicate/O slicedData,root:Packages:NIST:Event:dispsliceData,root:Packages:NIST:Event:logSlicedData
533        Wave logSlicedData = root:Packages:NIST:Event:logSlicedData
534        logslicedData = log(slicedData)
535
536        SetDataFolder root:
537        return(0)
538End
539
540
541Function SortTimeData()
542
543// now before binning, sort the data
544
545        //this is slow - undoing the sorting and starting over, but if you don't,
546        // you'll never be able to undo the sort
547        //
548        SetDataFolder root:Packages:NIST:Event:
549
550        KillWaves/Z OscSortIndex
551//      Print WaveExists($"root:Packages:NIST:Event:OscSortIndex")
552       
553        if(WaveExists($"root:Packages:NIST:Event:OscSortIndex") == 0 )
554                Duplicate/O rescaledTime OscSortIndex
555                MakeIndex rescaledTime OscSortIndex
556                IndexSort OscSortIndex, yLoc,xLoc,timePt,rescaledTime   
557        Endif
558       
559        SetDataFolder root:
560        return(0)
561End
562
563
564
565Function SetLinearBins(binEndTime,nslices,t_longest)
566        Wave binEndTime
567        Variable nslices,t_longest
568
569        Variable del,ii,t2
570        binEndTime[0]=0         //so the bar graph plots right...
571        del = t_longest/nslices
572       
573        for(ii=0;ii<nslices;ii+=1)
574                t2 = (ii+1)*del
575                binEndTime[ii+1] = t2
576        endfor
577        binEndTime[ii+1] = t_longest*(1-1e-6)           //otherwise floating point errors such that the last time point is off the end of the Binary search
578
579        return(0)       
580End
581
582
583Function SetLogBins(binEndTime,nslices,t_longest)
584        Wave binEndTime
585        Variable nslices,t_longest
586
587        Variable tMin,ii
588
589        Wave rescaledTime = root:Packages:NIST:Event:rescaledTime
590       
591        binEndTime[0]=0         //so the bar graph plots right...
592
593        // just like the log-scaled q-points
594        tMin = rescaledTime[1]/1                        //just a guess... can't use tMin=0, and rescaledTime[0] == 0 by definition
595        Print rescaledTime[1], tMin
596        for(ii=0;ii<nslices;ii+=1)
597                binEndTime[ii+1] =alog(log(tMin) + (ii+1)*((log(t_longest)-log(tMin))/nslices))
598        endfor
599        binEndTime[ii+1] = t_longest            //otherwise floating point errors such that the last time point is off the end of the Binary search
600       
601        return(0)
602End
603
604Function MakeFibonacciWave(w,num)
605        Wave w
606        Variable num
607
608        //skip the initial zero
609        Variable f1,f2,ii
610        f1=1
611        f2=1
612        w[0] = f1
613        w[1] = f2
614        for(ii=2;ii<num;ii+=1)
615                w[ii] = f1+f2
616                f1=f2
617                f2=w[ii]
618        endfor
619               
620        return(0)
621end
622
623Function SetFibonacciBins(binEndTime,nslices,t_longest)
624        Wave binEndTime
625        Variable nslices,t_longest
626
627        Variable tMin,ii,total,t2,tmp
628        Make/O/D/N=(nslices) fibo
629        fibo=0
630        MakeFibonacciWave(fibo,nslices)
631       
632//      Make/O/D tmpFib={1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946}
633
634        binEndTime[0]=0         //so the bar graph plots right...
635        total = sum(fibo,0,nslices-1)           //total number of "pieces"
636       
637        tmp=0
638        for(ii=0;ii<nslices;ii+=1)
639                t2 = sum(fibo,0,ii)/total*t_longest
640                binEndTime[ii+1] = t2
641        endfor
642        binEndTime[ii+1] = t_longest            //otherwise floating point errors such that the last time point is off the end of the Binary search
643       
644        return(0)
645End
646
647
648
649
650Function LoadEventLog_Button(ctrlName) : ButtonControl
651        String ctrlName
652
653        NVAR mode=root:Packages:NIST:gEvent_mode
654       
655        if(mode == 0)
656                Stream_LoadEventLog("")
657        endif
658       
659        if(mode == 1)
660                Osc_LoadEventLog("")
661        endif
662       
663        DifferentiatedTime()
664       
665        return(0)
666End
667
668// for the mode of "one continuous exposure"
669//
670Function Stream_LoadEventLog(ctrlName)
671        String ctrlName
672       
673        Variable fileref
674
675        SVAR filename = root:Packages:NIST:gEvent_logfile
676        NVAR prescan = root:Packages:NIST:gEvent_prescan
677//      NVAR slicewidth = root:Packages:NIST:gEvent_slicewidth
678        NVAR nslices = root:Packages:NIST:gEvent_nslices
679        NVAR t_longest = root:Packages:NIST:gEvent_t_longest
680       
681        String fileFilters = "All Files:.*;Data Files (*.txt):.txt;"
682       
683        Open/R/D/F=fileFilters fileref
684        filename = S_filename
685       
686        LoadEvents()
687       
688        SetDataFolder root:Packages:NIST:Event:
689
690tic()
691        Wave timePt=timePt
692        Wave xLoc=xLoc
693        Wave yLoc=yLoc
694        CleanupTimes(xLoc,yLoc,timePt)          //remove zeroes
695       
696toc()
697
698        Duplicate/O timePt rescaledTime
699        rescaledTime = 1e-7*(timePt-timePt[0])          //convert to seconds and start from zero
700        t_longest = waveMax(rescaledTime)               //should be the last point
701
702        SetDataFolder root:
703
704        return(0)
705End
706
707// for the mode "oscillatory"
708//
709Function Osc_LoadEventLog(ctrlName)
710        String ctrlName
711       
712        Variable fileref
713
714        SVAR filename = root:Packages:NIST:gEvent_logfile
715        NVAR prescan = root:Packages:NIST:gEvent_prescan
716//      NVAR slicewidth = root:Packages:NIST:gEvent_slicewidth
717        NVAR nslices = root:Packages:NIST:gEvent_nslices
718        NVAR t_longest = root:Packages:NIST:gEvent_t_longest
719       
720        String fileFilters = "All Files:.*;Data Files (*.txt):.txt;"
721       
722        Open/R/D/F=fileFilters fileref
723        filename = S_filename
724       
725        LoadEvents()
726       
727        SetDataFolder root:Packages:NIST:Event:
728
729        Wave timePt=timePt
730        Wave xLoc=xLoc
731        Wave yLoc=yLoc
732        CleanupTimes(xLoc,yLoc,timePt)          //remove zeroes
733       
734        Duplicate/O timePt rescaledTime
735        rescaledTime *= 1e-7                    //convert to seconds and that's all
736        t_longest = waveMax(rescaledTime)               //won't be the last point, so get it this way
737
738        KillWaves/Z OscSortIndex                        //to make sure that there is no old index hanging around
739
740        SetDataFolder root:
741
742        return(0)
743End
744
745
746
747Function CleanupTimes(xLoc,yLoc,timePt)
748        Wave xLoc,yLoc,timePt
749
750        // start at the back and remove zeros
751        Variable num=numpnts(xLoc),ii
752       
753        ii=num
754        do
755                ii -= 1
756                if(timePt[ii] == 0 && xLoc[ii] == 0 && yLoc[ii] == 0)
757                        DeletePoints ii, 1, xLoc,yLoc,timePt
758                endif
759        while(timePt[ii-1] == 0 && xLoc[ii-1] == 0 && yLoc[ii-1] == 0)
760       
761        return(0)
762End
763
764Function LogIntEvent_Proc(ctrlName,checked) : CheckBoxControl
765        String ctrlName
766        Variable checked
767               
768        SetDataFolder root:Packages:NIST:Event
769        if(checked)
770                Duplicate/O logslicedData dispsliceData
771        else
772                Duplicate/O slicedData dispsliceData
773        endif
774
775        SetDataFolder root:
776End
777
778
779
780
781Function sliceSelectEvent_Proc(ctrlName, varNum, varStr, varName) : SetVariableControl
782        String ctrlName
783        Variable varNum
784        String varStr
785        String varName
786       
787        NVAR nslices = root:Packages:NIST:gEvent_nslices
788        NVAR selectedslice = root:Packages:NIST:gEvent_tsdisp
789       
790        if(varNum < 0)
791                selectedslice = 0
792                DoUpdate
793        elseif (varNum > nslices-1)
794                selectedslice = nslices-1
795                DoUpdate
796        else
797                ModifyImage/W=EventModePanel#Event_slicegraph ''#0 plane = varNum
798        endif
799
800End
801
802Function DifferentiatedTime()
803
804        Wave rescaledTime = root:Packages:NIST:Event:rescaledTime
805       
806        Differentiate rescaledTime/D=rescaledTime_DIF
807//      Display rescaledTime,rescaledTime_DIF
808        DoWindow/F Differentiated_Time
809        if(V_flag == 0)
810                Display/N=Differentiated_Time/K=1 rescaledTime_DIF
811                Legend
812                Modifygraph gaps=0
813                ModifyGraph zero(left)=1
814                Label left "\\Z14Delta (dt/event)"
815                Label bottom "\\Z14Event number"
816        endif
817       
818        return(0)
819End
820
821
822//
823// for the bit shifts, see the decimal-binary conversion
824// http://www.binaryconvert.com/convert_unsigned_int.html
825//
826//              K0 = 536870912
827//              Print (K0 & 0x08000000)/134217728       //bit 27 only, shift by 2^27
828//              Print (K0 & 0x10000000)/268435456               //bit 28 only, shift by 2^28
829//              Print (K0 & 0x20000000)/536870912               //bit 29 only, shift by 2^29
830//
831//
832Function LoadEvents()
833       
834        NVAR time_msw = root:Packages:NIST:gEvent_time_msw
835        NVAR time_lsw = root:Packages:NIST:gEvent_time_lsw
836        NVAR t_longest = root:Packages:NIST:gEvent_t_longest
837       
838        SVAR filepathstr = root:Packages:NIST:gEvent_logfile
839        SVAR dispStr = root:Packages:NIST:gEventDisplayString
840       
841        SetDataFolder root:Packages:NIST:Event
842
843        Variable fileref
844        String buffer
845        String fileStr,tmpStr
846        Variable dataval,timeval,type,numLines,verbose,verbose3
847        Variable xval,yval,rollBit,nRoll,roll_time,bit29,bit28,bit27
848        Variable ii,flaggedEvent,rolloverHappened,numBad=0,tmpPP=0
849        Variable Xmax, yMax
850       
851        xMax = 127              // number the detector from 0->127
852        yMax = 127
853       
854        verbose3 = 1                    //prints out the rollover events (type==3)
855        verbose = 0
856        numLines = 0
857
858       
859        // what I really need is the number of XY events
860        Variable numXYevents,num1,num2,num3,num0,totBytes,numPP,numT0,numDL,numFF,numZero
861        numXYevents = 0
862        num0 = 0
863        num1 = 0
864        num2 = 0
865        num3 = 0
866        numPP = 0
867        numT0 = 0
868        numDL = 0
869        numFF = 0
870        numZero = 0
871
872//tic()
873        Open/R fileref as filepathstr
874                FStatus fileref
875        Close fileref
876
877        totBytes = V_logEOF
878        Print "total bytes = ", totBytes
879       
880//toc()
881//
882
883
884// do a "pre-scan to get some of the counts, so that I can allocate space. This does
885// double the read time, but is still faster than adding points to waves as the file is read
886//     
887
888        tic()
889
890        Open/R fileref as filepathstr
891        do
892                do
893                        FReadLine fileref, buffer                       //skip the "blank" lines that have one character
894                while(strlen(buffer) == 1)             
895
896                if (strlen(buffer) == 0)
897                        break
898                endif
899               
900                sscanf buffer,"%x",dataval
901               
902                // two most sig bits (31-30)
903                type = (dataval & 0xC0000000)/1073741824                //right shift by 2^30
904                               
905                if(type == 0)
906                        num0 += 1
907                        numXYevents += 1
908                endif
909                if(type == 2)
910                        num2 += 1
911                        numXYevents += 1
912                endif
913                if(type == 1)
914                        num1 += 1
915                endif
916                if(type == 3)
917                        num3 += 1
918                endif   
919               
920                bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
921               
922                if(type==0 || type==2)
923                        numPP += round(bit29)
924                endif
925               
926                if(type==1 || type==3)
927                        numT0 += round(bit29)
928                endif
929               
930                if(dataval == 0)
931                        numZero += 1
932                endif
933               
934        while(1)
935        Close fileref
936//              done counting the number of XY events
937        toc()
938       
939       
940//
941//     
942//      Printf "numXYevents = %d\r",numXYevents
943//      Printf "XY = num0 = %d\r",num0
944//      Printf "XY time = num2 = %d\r",num2
945//      Printf "time MSW = num1 = %d\r",num1
946//      Printf "Rollover = num3 = %d\r",num3
947//      Printf "num0 + num2 = %d\r",num0+num2
948
949// dispStr will be displayed on the panel
950        fileStr = ParseFilePath(0, filepathstr, ":", 1, 0)
951       
952        sprintf tmpStr, "%s: %d total bytes\r",fileStr,totBytes
953        dispStr = tmpStr
954        sprintf tmpStr,"numXYevents = %d\r",numXYevents
955        dispStr += tmpStr
956//      sprintf tmpStr,"XY = num0 = %d\r",num0
957//      dispStr += tmpStr
958//      sprintf tmpStr,"\rXY time = num2 = %d\rtime MSW = num1 = %d",num2,num1
959//      dispStr += tmpStr
960//      sprintf tmpStr,"XY time = num2 = %d\r",num2
961//      dispStr += tmpStr
962//      sprintf tmpStr,"time MSW = num1 = %d\r",num1
963//      dispStr += tmpStr
964        sprintf tmpStr,"PP = %d  :  ",numPP
965        dispStr += tmpStr
966        sprintf tmpStr,"ZeroData = %d\r",numZero
967        dispStr += tmpStr
968        sprintf tmpStr,"Rollover = %d",num3
969        dispStr += tmpStr
970
971       
972       
973        Make/O/U/N=(numXYevents) xLoc,yLoc
974        Make/O/D/N=(numXYevents) timePt
975//      Make/O/U/N=(totBytes/4) xLoc,yLoc               //too large, trim when done (bad idea)
976//      Make/O/D/N=(totBytes/4) timePt
977        Make/O/D/N=1000 badTimePt,badEventNum,PPTime,PPEventNum
978        badTimePt=0
979        badEventNum=0
980        PPTime=0
981        PPEventNum=0
982        xLoc=0
983        yLoc=0
984        timePt=0
985       
986        nRoll = 0               //number of rollover events
987        roll_time = 2^26                //units of 10-7 sec
988       
989        NVAR removeBadEvents = root:Packages:NIST:gRemoveBadEvents
990       
991        time_msw=0
992       
993        tic()
994       
995        ii = 0
996       
997        Open/R fileref as filepathstr
998       
999        // remove events at the beginning up to a type==2 so that the msw and lsw times are reset properly
1000        if(RemoveBadEvents == 1)
1001                do
1002                        do
1003                                FReadLine fileref, buffer                       //skip the "blank" lines that have one character
1004                        while(strlen(buffer) == 1)             
1005       
1006                        if (strlen(buffer) == 0)
1007                                break
1008                        endif
1009                       
1010                        sscanf buffer,"%x",dataval
1011                // two most sig bits (31-30)
1012                        type = (dataval & 0xC0000000)/1073741824                //right shift by 2^30
1013                       
1014                        if(type == 2)
1015                                // this is the first event with a proper time value, so process the XY-time event as ususal
1016                                // and then break to drop to the main loop, where the next event == type 1
1017                               
1018                                xval = xMax - (dataval & 255)                                           //last 8 bits (7-0)
1019                                yval = (dataval & 65280)/256                                            //bits 15-8, right shift by 2^8
1020               
1021                                time_lsw = (dataval & 536805376)/65536                  //13 bits, 28-16, right shift by 2^16
1022               
1023                                if(verbose)
1024                //                                      printf "%u : %u : %u : %u\r",dataval,time_lsw,time_msw,timeval
1025                                        printf "%u : %u : %u : %u\r",dataval,timeval,xval,yval
1026                                endif
1027                               
1028                                // this is the first point, be sure that ii = 0
1029                                ii = 0
1030                                xLoc[ii] = xval
1031                                yLoc[ii] = yval
1032                               
1033                                Print "At beginning of file, numBad = ",numBad
1034                                break   // the next do loop processes the bulk of the file (** the next event == type 1 = MIR)
1035                        else
1036                                numBad += 1
1037                        endif
1038                       
1039                        //ii+=1         don't increment the counter
1040                while(1)
1041        endif
1042       
1043        // now read the main portion of the file.
1044        do
1045                do
1046                        FReadLine fileref, buffer                       //skip the "blank" lines that have one character
1047                while(strlen(buffer) == 1)             
1048
1049                if (strlen(buffer) == 0)
1050                        break
1051                endif
1052               
1053                sscanf buffer,"%x",dataval
1054               
1055
1056//              type = (dataval & ~(2^32 - 2^30 -1))/2^30
1057
1058                // two most sig bits (31-30)
1059                type = (dataval & 0xC0000000)/1073741824                //right shift by 2^30
1060               
1061//              // if the first event, read the time_msw, since this is not always reset. if the first event is XYM, then it's OK,
1062//              // but if the first event is XY, then the first few events will have msw=0 until an XYM forces a read of MSW in the
1063//              // subsequent MIR event.
1064//              // So do it now.
1065//              if(ii==0 && RemoveBadEvents == 1)
1066//                      time_msw =  (dataval & 536805376)/65536                 //13 bits, 28-16, right shift by 2^16
1067//              endif
1068
1069                //
1070                //Constant ATXY = 0
1071                //Constant ATXYM = 2
1072                //Constant ATMIR = 1
1073                //Constant ATMAR = 3
1074                //
1075                                               
1076                if(verbose > 0)
1077                        verbose -= 1
1078                endif
1079//             
1080                switch(type)
1081                        case ATXY:              // 0
1082                                if(verbose)             
1083                                        printf "XY : "         
1084                                endif
1085                               
1086                                // if the datavalue is == 0, just skip it now (it can only be interpreted as type 0, obviously
1087                                if(dataval == 0 && RemoveBadEvents == 1)
1088                                        break           //don't increment ii
1089                                endif
1090                               
1091                                // if it's a pileup event, skip it now (this can be either type 0 or 2)
1092                                bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1093                                if(bit29 == 1 && RemoveBadEvents == 1)
1094                                        PPTime[tmpPP] = timeval
1095                                        PPEventNum[tmpPP] = ii
1096                                        tmpPP += 1
1097                                        break           //don't increment ii
1098                                endif
1099                               
1100//                              xval = ~(dataval & ~(2^32 - 2^8)) & 127
1101//                              yval = ((dataval & ~(2^32 - 2^16 ))/2^8) & 127
1102//                              time_lsw = (dataval & ~(2^32 - 2^29))/2^16
1103
1104                                xval = xMax - (dataval & 255)                                           //last 8 bits (7-0)
1105                                yval = (dataval & 65280)/256                                            //bits 15-8, right shift by 2^8
1106                                time_lsw = (dataval & 536805376)/65536                  //13 bits, 28-16, right shift by 2^16
1107
1108                                timeval = trunc( nRoll*roll_time + (time_msw * (8192)) + time_lsw )             //left shift msw by 2^13, then add in lsw, as an integer
1109                                if (timeval > t_longest)
1110                                        t_longest = timeval
1111                                endif
1112                               
1113                               
1114                                // catch the "bad" events:
1115                                // if an XY event follows a rollover, time_msw is 0 by definition, but does not immediately get
1116                                // re-evalulated here. Throw out only the immediately following points where msw is still 8191
1117                                if(rolloverHappened && RemoveBadEvents == 1)
1118                                        // maybe a bad event
1119                                        if(time_msw == 8191)
1120                                                badTimePt[numBad] = timeVal
1121                                                badEventNum[numBad] = ii
1122                                                numBad +=1
1123                                        else
1124                                                // time_msw has been reset, points are good now, so keep this one
1125                                                xLoc[ii] = xval
1126                                                yLoc[ii] = yval
1127                                                timePt[ii] = timeval
1128                                               
1129//                                              if(xval == 127 && yval == 0)
1130//                                                      // check bit 29
1131//                                                      bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1132//                                                      Print "XY=127,0 : bit29 = ",bit29
1133//                                              endif
1134                                               
1135                                                ii+=1
1136                                                rolloverHappened = 0
1137                                        endif
1138                                else
1139                                        // normal processing of good point, keep it
1140                                        xLoc[ii] = xval
1141                                        yLoc[ii] = yval
1142                                        timePt[ii] = timeval
1143                               
1144//                                      if(xval == 127 && yval == 0)
1145//                                              // check bit 29
1146//                                              bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1147//                                              Printf "XY=127,0 : bit29 = %u : d=%u\r",bit29,dataval
1148//                                      endif
1149                                        ii+=1
1150                                endif
1151
1152
1153                                if(verbose)             
1154//                                      printf "%u : %u : %u : %u\r",dataval,time_lsw,time_msw,timeval
1155                                        printf "d=%u : t=%u : msw=%u : lsw=%u : %u : %u \r",dataval,timeval,time_msw,time_lsw,xval,yval
1156                                endif                           
1157       
1158//                              verbose = 0
1159                                break
1160                        case ATXYM: // 2
1161                                if(verbose)
1162                                        printf "XYM : "
1163                                endif
1164                               
1165                                // if it's a pileup event, skip it now (this can be either type 0 or 2)
1166                                // - but can I do this if this is an XY-time event? This will lead to a wrong time, and a time
1167                                // assigned to an XY (0,0)...
1168                                bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1169                                if(bit29 == 1 && RemoveBadEvents == 1)
1170                                        Print "*****Bit 29 (PP) event set for Type==2, but not handled, ii = ",ii
1171//                                      break           //don't increment ii
1172                                endif
1173                               
1174//                              xval = ~(dataval & ~(2^32 - 2^8)) & 127
1175//                              yval = ((dataval & ~(2^32 - 2^16 ))/2^8) & 127
1176//                              time_lsw =  (dataval & ~(2^32 - 2^29 ))/2^16            //this method gives a FP result!! likely since the "^" operation gives FP result...
1177
1178                                xval = xMax - (dataval & 255)                                           //last 8 bits (7-0)
1179                                yval = (dataval & 65280)/256                                            //bits 15-8, right shift by 2^8
1180
1181                                time_lsw = (dataval & 536805376)/65536                  //13 bits, 28-16, right shift by 2^16 (result is integer)
1182
1183                                if(verbose)
1184//                                      printf "%u : %u : %u : %u\r",dataval,time_lsw,time_msw,timeval
1185                                        printf "%u : %u : %u : %u\r",dataval,timeval,xval,yval
1186                                endif
1187                               
1188                                xLoc[ii] = xval
1189                                yLoc[ii] = yval
1190
1191                                // don't fill in the time yet, or increment the index ii
1192                                // the next event MUST be ATMIR with the MSW time bits
1193                                //
1194//                              verbose = 0
1195                                break
1196                        case ATMIR:  // 1
1197                                if(verbose)
1198                                        printf "MIR : "
1199                                endif
1200
1201                                time_msw =  (dataval & 536805376)/65536                 //13 bits, 28-16, right shift by 2^16
1202                                timeval = trunc( nRoll*roll_time + (time_msw * (8192)) + time_lsw )
1203                                if (timeval > t_longest)
1204                                        t_longest = timeval
1205                                endif
1206                                if(verbose)
1207//                                      printf "%u : %u : %u : %u\r",dataval,time_lsw,time_msw,timeval
1208                                        printf "d=%u : t=%u : msw=%u : lsw=%u : tlong=%u\r",dataval,timeval,time_msw,time_lsw,t_longest
1209                                endif
1210                               
1211                                // the XY position was in the previous event ATXYM
1212                                timePt[ii] = timeval
1213
1214//                              bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1215//                              if(bit29 != 0)
1216//                                      Printf "bit29 = 1 at ii = %d : type = %d\r",ii,type
1217//                              endif
1218                                                               
1219                                ii+=1
1220//                              verbose = 0
1221                                break
1222                        case ATMAR:  // 3
1223                                if(verbose3)
1224//                                      verbose = 15
1225//                                      verbose = 2
1226                                        printf "MAR : "
1227                                endif
1228                               
1229                                // do something with the rollover event?
1230                               
1231                                // check bit 29
1232                                bit29 = (dataval & 0x20000000)/536870912                //bit 29 only , shift by 2^29
1233                                nRoll += 1
1234// not doing anything with these bits yet                               
1235                                bit27 = (dataval & 0x08000000)/134217728        //bit 27 only, shift by 2^27
1236                                bit28 = (dataval & 0x10000000)/268435456                //bit 28 only, shift by 2^28
1237
1238                                if(verbose3)
1239                                        printf "d=%u : b29=%u : b28=%u : b27=%u : #Roll=%u \r",dataval,bit29, bit28, bit27,nRoll
1240                                endif
1241                               
1242                                rolloverHappened = 1
1243
1244                                break
1245                endswitch
1246               
1247//              if(ii<18)
1248//                      printf "TYPE=%d : ii=%d : d=%u : t=%u : msw=%u : lsw=%u : %u : %u \r",type,ii,dataval,timeval,time_msw,time_lsw,xval,yval
1249//              endif   
1250                       
1251        while(1)
1252       
1253       
1254        Close fileref
1255       
1256        toc()
1257       
1258        sPrintf tmpStr,"\rBad Events = numBad = %d (%g %% of events)",numBad,numBad/numXYevents*100
1259        dispStr += tmpStr
1260
1261        SetDataFolder root:
1262       
1263        return(0)
1264       
1265End
1266
1267///
1268
1269Proc BinEventBarGraph()
1270       
1271        DoWindow/F EventBarGraph
1272        if(V_flag == 0)
1273                PauseUpdate; Silent 1           // building window...
1274                String fldrSav0= GetDataFolder(1)
1275                SetDataFolder root:Packages:NIST:Event:
1276                Display /W=(110,705,610,1132)/N=EventBarGraph /K=1 binCount vs binEndTime
1277                SetDataFolder fldrSav0
1278                ModifyGraph mode=5
1279                ModifyGraph marker=19
1280                ModifyGraph lSize=2
1281                ModifyGraph rgb=(0,0,0)
1282                ModifyGraph msize=2
1283                ModifyGraph hbFill=2
1284                ModifyGraph gaps=0
1285                ModifyGraph usePlusRGB=1
1286                ModifyGraph toMode=1
1287                ModifyGraph useBarStrokeRGB=1
1288        //      ModifyGraph log=1
1289                ModifyGraph standoff=0
1290                Label bottom "\\Z14Time (seconds)"
1291                Label left "\\Z14Number of Events"
1292        //      SetAxis left 0.1,4189
1293        //      SetAxis bottom 0.0001,180.84853
1294        endif
1295End
1296
1297
1298Proc ShowBinTable() : Table
1299
1300        DoWindow/F BinEventTable
1301        if(V_flag == 0)
1302                PauseUpdate; Silent 1           // building window...
1303                String fldrSav0= GetDataFolder(1)
1304                SetDataFolder root:Packages:NIST:Event:
1305                Edit/W=(498,699,1003,955) /K=1/N=BinEventTable binCount,binEndTime
1306                ModifyTable format(Point)=1,sigDigits(binEndTime)=16,width(binEndTime)=218
1307                SetDataFolder fldrSav0
1308        endif
1309EndMacro
1310
1311
1312// only show the first 1500 data points
1313//
1314Proc ShowRescaledTimeGraph() : Graph
1315
1316        DoWindow/F RescaledTimeGraph
1317        if(V_flag == 0)
1318                PauseUpdate; Silent 1           // building window...
1319                String fldrSav0= GetDataFolder(1)
1320                SetDataFolder root:Packages:NIST:Event:
1321                Display /W=(25,44,486,356)/K=1/N=RescaledTimeGraph rescaledTime
1322                SetDataFolder fldrSav0
1323                ModifyGraph mode=4
1324                ModifyGraph marker=19
1325                ModifyGraph rgb(rescaledTime)=(0,0,0)
1326                ModifyGraph msize=2
1327//              SetAxis/A=2 left                        //only autoscale the visible data (based on the bottom limits)
1328//              SetAxis bottom 0,1500
1329                ErrorBars rescaledTime OFF
1330                Label left "\\Z14Time (seconds)"
1331                Label bottom "\\Z14Event number"
1332                ShowInfo
1333        endif
1334       
1335EndMacro
1336
1337
1338
1339Proc ExportSlicesAsVAX(firstNum,prefix)
1340        Variable firstNum=1
1341        String prefix="SAMPL"
1342
1343        SaveSlicesAsVAX(firstNum,prefix[0,4])           //make sure that the prefix is 5 chars
1344End
1345
1346//////// procedures to be able to export the slices as RAW VAX files.
1347
1348// 1- load the raw data file to use the header (it must already be in RAW)
1349// 1.5- copy the raw data to the temp folder (STO)
1350// 1.7- ask for the prefix and starting run number (these are passed in)
1351// 2- copy the slice of data to the temp folder (STO)
1352// 3- touch up the time/counts in the slice header values in STO
1353// 4- write out the VAX file
1354// 5- repeat (2-4) for the number of slices
1355//
1356//
1357Function SaveSlicesAsVAX(firstNum,prefix)
1358        Variable firstNum
1359        String prefix
1360
1361        DoAlert 1,"Is the full data file loaded as a RAW data file? If not, load it and start over..."
1362        if(V_flag == 2)
1363                return (0)
1364        endif
1365       
1366// copy the contents of RAW to STO so I can work from there
1367        CopyWorkContents("RAW","STO")
1368
1369        // now declare all of the waves, now that they are sure to be there
1370
1371        WAVE slicedData=root:Packages:NIST:Event:slicedData
1372        Make/O/D/N=(128,128) curSlice
1373       
1374        NVAR nslices = root:Packages:NIST:gEvent_nslices
1375        WAVE binEndTime = root:Packages:NIST:Event:binEndTime
1376
1377        Wave rw=root:Packages:NIST:STO:realsRead
1378        Wave iw=root:Packages:NIST:STO:integersRead
1379        Wave/T tw=root:Packages:NIST:STO:textRead
1380        Wave data=root:Packages:NIST:STO:data
1381        Wave linear_data=root:Packages:NIST:STO:linear_data
1382       
1383       
1384        Wave rw_raw=root:Packages:NIST:RAW:realsRead
1385        Wave iw_raw=root:Packages:NIST:RAW:integersRead
1386        Wave/T tw_raw=root:Packages:NIST:RAW:textRead
1387
1388// for generating the alphanumeric
1389        String timeStr= secs2date(datetime,-1)
1390        String monthStr=StringFromList(1, timeStr  ,"/")
1391        String numStr="",labelStr
1392
1393        Variable ii,err,binFraction
1394       
1395        for(ii=0;ii<nslices;ii+=1)
1396
1397                //get the current slice and put it in the STO folder
1398                curSlice = slicedData[p][q][ii]
1399                data = curSlice
1400                linear_data = curSlice
1401               
1402                // touch up the header as needed
1403                // count time = iw[2]
1404                // monCt = rw[0]
1405                // detCt = rw[2]
1406                //tw[0] must now be the file name
1407                //
1408                // count time = fraction of total binning * total count time
1409                binFraction = (binEndTime[ii+1]-binEndTime[ii])/(binEndTime[nslices]-binEndTime[0])
1410               
1411                iw[2] = trunc(binFraction*iw_raw[2])
1412                rw[0] = trunc(binFraction*rw_raw[0])
1413                rw[2] = sum(curSlice,-inf,inf)          //total counts in slice
1414       
1415                if(firstNum<10)
1416                        numStr = "00"+num2str(firstNum)
1417                else
1418                        if(firstNum<100)
1419                                numStr = "0"+num2str(firstNum)
1420                        else
1421                                numStr = num2str(firstNum)
1422                        Endif
1423                Endif   
1424                tw[0] = prefix+numstr+".SA2_EVE_"+(num2char(str2num(monthStr)+64))+numStr
1425                labelStr = tw_raw[6]
1426               
1427                labelStr = PadString(labelStr,60,0x20)  //60 fortran-style spaces
1428                tw[6] = labelStr[0,59]
1429               
1430                //write out the file - this uses the tw[0] and home path
1431                Write_VAXRaw_Data("STO","",0)
1432
1433                //increment the run number, alpha
1434                firstNum += 1   
1435        endfor
1436
1437        return(0)
1438End
1439
1440
1441
1442
1443
1444/////////////
1445//The histogramming
1446//
1447// 6 AUG 2012
1448//
1449// from Igor Exchange, RGerkin
1450//  http://www.igorexchange.com/node/1373
1451// -- see the related thread on the mailing list
1452//
1453
1454//
1455// Now see if this can be succesfully applied to the timeslicing data sets
1456// -- talk to Jeff about what he's gotten implemented, and what's still missing
1457// - both in timeslicing, and in TISANE
1458// - un-scale the wave? or make it work as 128x128
1459
1460Function Setup_JointHistogram()
1461
1462//      tic()
1463
1464        make/D /o/n=1000000 data1=gnoise(1), data2=gnoise(1)
1465        make/D /o/n=(25,25) myHist
1466        setscale x,-3,3,myHist
1467        setscale y,-3,3,myHist
1468        IndexForHistogram(data1,data2,myhist)
1469        Wave index=SavedIndex
1470        JointHistogram(data1,data2,myHist,index)
1471        NewImage myHist
1472       
1473//      toc()
1474       
1475End
1476
1477
1478Function JointHistogram(w0,w1,hist,index)
1479        wave w0,w1,hist,index
1480 
1481        variable bins0=dimsize(hist,0)
1482        variable bins1=dimsize(hist,1)
1483        variable n=numpnts(w0)
1484        variable left0=dimoffset(hist,0)
1485        variable left1=dimoffset(hist,1)
1486        variable right0=left0+bins0*dimdelta(hist,0)
1487        variable right1=left1+bins1*dimdelta(hist,1)
1488       
1489        // Compute the histogram and redimension it. 
1490        histogram /b={0,1,bins0*bins1} index,hist
1491        redimension/D /n=(bins0,bins1) hist // Redimension to 2D. 
1492        setscale x,left0,right0,hist // Fix the histogram scaling in the x-dimension. 
1493        setscale y,left1,right1,hist // Fix the histogram scaling in the y-dimension. 
1494End
1495
1496
1497// need a way of visualizing the bin spacing / number of bins vs the full time of the data collection
1498// then set the range of the source to send to the joint histogram operation
1499// to assign to arrays (or a 3D wave)
1500//
1501// -- see my model with the "layered" form factor - or whatever I called it. That shows different
1502// binning and visualizing as bar graphs.
1503//
1504// -- just need to send x2pnt or findLevel, or something similar to define the POINT
1505// values
1506//
1507// can also speed this up since the index only needs to be done once, so the
1508// histogram operation can be done separately, as the bins require
1509//
1510//
1511Function JointHistogramWithRange(w0,w1,hist,index,pt1,pt2)
1512        wave w0,w1,hist,index
1513        Variable pt1,pt2
1514 
1515        variable bins0=dimsize(hist,0)
1516        variable bins1=dimsize(hist,1)
1517        variable n=numpnts(w0)
1518        variable left0=dimoffset(hist,0)
1519        variable left1=dimoffset(hist,1)
1520        variable right0=left0+bins0*dimdelta(hist,0)
1521        variable right1=left1+bins1*dimdelta(hist,1)
1522
1523        // Compute the histogram and redimension it. 
1524        histogram /b={0,1,bins0*bins1}/R=[pt1,pt2] index,hist
1525        redimension/D /n=(bins0,bins1) hist // Redimension to 2D. 
1526        setscale x,left0,right0,hist // Fix the histogram scaling in the x-dimension. 
1527        setscale y,left1,right1,hist // Fix the histogram scaling in the y-dimension. 
1528End
1529
1530
1531// just does the indexing, creates wave SavedIndex in the current folder for the index
1532//
1533Function IndexForHistogram(w0,w1,hist)
1534        wave w0,w1,hist
1535 
1536        variable bins0=dimsize(hist,0)
1537        variable bins1=dimsize(hist,1)
1538        variable n=numpnts(w0)
1539        variable left0=dimoffset(hist,0)
1540        variable left1=dimoffset(hist,1)
1541        variable right0=left0+bins0*dimdelta(hist,0)
1542        variable right1=left1+bins1*dimdelta(hist,1)
1543 
1544        // Scale between 0 and the number of bins to create an index wave. 
1545        if(ThreadProcessorCount<4) // For older machines, matrixop is faster. 
1546                matrixop /free idx=round(bins0*(w0-left0)/(right0-left0))+bins0*round(bins1*(w1-left1)/(right1-left1))
1547        else // For newer machines with many cores, multithreading with make is faster. 
1548                make/free/n=(n) idx
1549                multithread idx=round(bins0*(w0-left0)/(right0-left0))+bins0*round(bins1*(w1-left1)/(right1-left1))
1550        endif
1551 
1552        KillWaves/Z SavedIndex
1553        MoveWave idx,SavedIndex
1554       
1555//      // Compute the histogram and redimension it. 
1556//      histogram /b={0,1,bins0*bins1} idx,hist
1557//      redimension /n=(bins0,bins1) hist // Redimension to 2D. 
1558//      setscale x,left0,right0,hist // Fix the histogram scaling in the x-dimension. 
1559//      setscale y,left1,right1,hist // Fix the histogram scaling in the y-dimension. 
1560End
1561
1562
1563
1564
1565///////
1566//// @ IgorExchange
1567////TicToc
1568////Posted April 16th, 2009 by bgallarda
1569////    ¥       in Programming 6.10.x
1570//     
1571//function tic()
1572//      variable/G tictoc = startMSTimer
1573//end
1574//
1575//function toc()
1576//      NVAR/Z tictoc
1577//      variable ttTime = stopMSTimer(tictoc)
1578//      printf "%g seconds\r", (ttTime/1e6)
1579//      killvariables/Z tictoc
1580//end
1581//
1582//
1583//Function testTicToc()
1584//
1585//      tic()
1586//      variable i
1587//      For(i=0;i<10000;i+=1)
1588//              make/O/N=512 temp = gnoise(2)
1589//              FFT temp
1590//      Endfor
1591//      killwaves/z temp
1592//      toc()
1593//End
1594//
1595////////////////
Note: See TracBrowser for help on using the repository browser.