A first look at the data from the 207Bi source (run described in previous elog entry, ID 27)

The main conclusions are (see description of spectra further bellow):

- NNAIDA11 and NNAIDA13 were running stable, even though NNAIDA11 had one channel with very high rate. 
NNAIDA12 and 14 were running unstably with frequent instances of Pause/Resume. A possible explanation is 
their higher data rates (due to a bad channel and noise, respectively).

- I think using only a window in time will not be sufficient to identify electron signals in the data. 
This is a particular issue for the data of NNAIDA14, where there is a high noise and a energy threshold, 
or some more ingenious condition, is likely required.


Plots were generated with the script in /Home/aestrade/AIDA/analysis/loopAIDAsort.cpp

Only a fraction of the 207Bi data was processed (corresponding to file R62_2). 


+ Distribution of time-stamps

R61part_ts_dist_adc_hit.png: The spectra show the difference between the 
time-stamp of a given ADC hit (ts_i) and the time-stamp of subsequent ADC 
hits (ts_i+n):

	Delta ts(i+n,i) = ts_(i+n) - ts(i)

So the first plot, for Delta ts(i+1,i), is the difference between each ADC 
hit and the next ADC hit. The second plot is the ts difference between each 
ADC hit and the second to next ADC hit, and so on... 

The data mixes the spectra for all FEE cards and all ADC channels. One can 
still see a clear structure with a peak at low values of Delta ts, and then 
a second distribution up to Delta ts= 30*n usec. These is the time it takes 
to loop through all 16 channels of the ADC (2 usec/channel), so is likely 
the distribution generated by one channel is firing at a very high rate.

I'll make similar plots with conditions to mask out noisy channels and/or 
pulser events to look for a value of the coincidence time-window to use to 
reconstruct events.

+ Rates

R61part_rates.png: the spectra shows various rates (in Hz) as a function of 
run time and of channel. The plots on the top are the rate of ADC hits (for 
low energy range) of each FEE module, and one showing the rate of ADC hits 
for the high energy range in all modules combined. The bottom row shows rate 
per channel, and the rate of Information type hits.

some conclusions: NNAIDA11 and 13 show a flat rate, and as will be seen from other plots are very stable 
during the run. NNAIDA11 has a larger rate than 13, but the difference is mostly due to a very high-rate 
channel; the rate in most channels is consistent with a 100 Hz pulser for both.

NNAIDA12 and 14 show the largest rate that can peak at 35kHz, and looks quite unstable. These modules also 
have a choppy run of the DAQ (many Pause/Resume). NNAIDA11 actually has similar rate to NNAIDA12 and 14, 
but is still stable.

Both NNAIDA11 and 12 have one channel wiht very high rate compared to the 
rest (rather than unusually noisy channel, could it be one that is always 
above the threshold of the slow discriminator?).


+ ADC Rate with fine granularity

R61part_t1_hits_ts_adc.png: These spectra show the ADC hits (low range) vs time but with a higher binning 
of the data (1 ms/bin). The one channel with a very high rate in NNAIDA11 and 12 is seen in red. Also that 
the data readout from NNAIDA12 and 14 is frequently halted by Pause/Resume signals. 

R61part_t1_hits_ts_adc_zoom.png: The second file hast the same spectra but zoomed in a narrow time window, 
and one can see the hits from the pulser 10 ms appart (as vertial lines with hits in all channels for 2D 
spectra). In between the pulser signals, as hits in individual channels, are hits from the source or from 
noise. For NNAIDA14 this white noise was very high, so at the binning of 1ms/bin this spectra there are 
many channels with hits in each time bin. I think it will be difficult to identify electron events from 
such spectra using only a time window as requirement for coincidence. 


+ Info Codes Rates

R61part_t1_hits_ts_info.png : The spectra show the rates of information words. The first plots are again 
for a narrow section of the run (same as previous spectra). One can see the frequent sequence of 
Pause/Resume for NNAIDA12 and 14. Also note discriminator data and ADC(high range) hits only come for 
NNAIDA12 (we used very high value for discriminator threshold).

R61part_ts_info_fee.png: The figure shows the distribution of the different information codes for each FEE 
module, but now for the full lenght of the run.



++ Sorted Root TTree fiels ++

All raw files of run R61 were processed with the 'beta' version of the Root 
sort code for event reconstruction (/homes/npg/AIDAsort/ in DL PC), but only 
up to the 'Calibration' step (no event reconstructino). 
R61_207Bi_2_sort.root used for above plots. 

Root tree saved here:

/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_0_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_0_sort.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_1_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_1_sort.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_2_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_2_sort.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_3_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_3_sort.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_4_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_4_sort.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_5_calib.root
/Disk/ds-sopa-personal/aestrade/rootfiles/AIDA/R61_207Bi_5_sort.root


A bug on the Root sort code was identified from this output: the code waits 
for a SYNC100 pulse from *each* FEE card to update their corresponding 
most-significant bits (MSB) for the timestamp, while one has to use *any* 
SYNC100 pulse to update the MSB of all FEE modules. As a consecuence, a 
(very small) fraction of the processed hits have the wrong time-stamp (off 
by bit 28).

/*********/
//#include <bitset>
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <sstream>
#include <string>
#include <ctime>

#include <TFile.h>
#include <TTree.h>
#include <TH1I.h>
#include <TH2I.h>
#include <TGraph.h>
#include <TCanvas.h>

//#include "Common.h"


//using namespace std;
/*********/


//ts_0 in usec
void LoopTree(string inFile, int downscale=1, long long n_last= -1, int ts_0=-1, bool b_print=false, bool b_quit_ts=false){



  struct struct_entry_sort{
    long long tm_stp; //reconstructed timestamp (MSB+LSB)
    long long info; //MBS info data (external timestamp), anything else(?)
    int mod_id;
    int ch_id;
    int type; // QQQ: 0= 20 MeV or 1 GeV (decays), 1= 20 GeV (checked pulser data only in type 0)
              // type>=10: type = info_code+10 (i.e., PAUSE, RESUME, SYNC100, etc...)
    int adc_data;
    bool sync_flag; // check SYNC100 pulses received for this module
    bool pause_flag; // check Pause signals followed by proper Resume signal: true= SYNC100 paused...
  };



  //***** histograms! many...
  //

  //delta ts: any->any [100]
  //          adc->adc [100]
  //          adc(feei)->adc(feej) [1]
  //          adc(sidei)->adc(sidej) [1]
  //          !adc->!adc [1]
  //1,2,3,5,10,15,20,50,100
  TH1D *Hdts_any[10];
  Hdts_any[0]= new TH1D("Hdts_any0","#Delta ts_{(i+1,i)} !ANY DATA;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[1]= new TH1D("Hdts_any1","#Delta ts_{(i+2,i)} !ANY DATA;ts_{i+2} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[2]= new TH1D("Hdts_any2","#Delta ts_{(i+3,i)} !ANY DATA;ts_{i+3} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[3]= new TH1D("Hdts_any3","#Delta ts_{(i+5,i)} !ANY DATA;ts_{i+5} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[4]= new TH1D("Hdts_any4","#Delta ts_{(i+10,i)} !ANY DATA;ts_{i+10} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[5]= new TH1D("Hdts_any5","#Delta ts_{(i+15,i)} !ANY DATA;ts_{i+15} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[6]= new TH1D("Hdts_any6","#Delta ts_{(i+20,i)} !ANY DATA;ts_{i+20} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[7]= new TH1D("Hdts_any7","#Delta ts_{(i+50,i)} !ANY DATA;ts_{i+50} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_any[8]= new TH1D("Hdts_any8","#Delta ts_{(i+100,i)} !ANY DATA;ts_{i+100} - ts_{i} [usec]",4400,-20,200); //200 us full scale

  TH1D *Hdts_adc[10];
  Hdts_adc[0]= new TH1D("Hdts_adc0","#Delta ts_{(i+1,i)} !ADC(low) DATA;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[1]= new TH1D("Hdts_adc1","#Delta ts_{(i+2,i)} !ADC(low) DATA;ts_{i+2} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[2]= new TH1D("Hdts_adc2","#Delta ts_{(i+3,i)} !ADC(low) DATA;ts_{i+3} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[3]= new TH1D("Hdts_adc3","#Delta ts_{(i+5,i)} !ADC(low) DATA;ts_{i+5} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[4]= new TH1D("Hdts_adc4","#Delta ts_{(i+10,i)} !ADC(low) DATA;ts_{i+10} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[5]= new TH1D("Hdts_adc5","#Delta ts_{(i+15,i)} !ADC(low) DATA;ts_{i+15} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[6]= new TH1D("Hdts_adc6","#Delta ts_{(i+20,i)} !ADC(low) DATA;ts_{i+20} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[7]= new TH1D("Hdts_adc7","#Delta ts_{(i+50,i)} !ADC(low) DATA;ts_{i+50} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_adc[8]= new TH1D("Hdts_adc8","#Delta ts_{(i+100,i)} !ADC(low) DATA;ts_{i+100} - ts_{i} [usec]",4400,-20,200); //200 us full scale

  TH1D *Hdts_fee[1];
  Hdts_fee[0]= new TH1D("Hdts_fee0","#Delta ts_{(i+1,i)} !ADC(low), diff. FEE;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale

  TH1D *Hdts_side[2];
  Hdts_side[0]= new TH1D("Hdts_side0","#Delta ts_{(i+1,i)} !ADC(low), side0->1;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale
  Hdts_side[1]= new TH1D("Hdts_side1","#Delta ts_{(i+1,i)} !ADC(low), side1->0;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale

  TH1D *Hdts_info[1];
  Hdts_info[0]= new TH1D("Hdts_info0","#Delta ts_{(i+1,i)} !info DATA;ts_{i+1} - ts_{i} [usec]",4400,-20,200); //200 us full scale
 
  TH1D *Hdts_ooo[1];
  Hdts_ooo[0]= new TH1D("Hdts_ooo0","#Delta ts_{(i+1,i)} !out-of-order!;ts_{i+1} - ts_{i} [usec]",15000,-3e6,0); //500 us full scale
 

  TH1D * Hts[2];
  Hts[0]= new TH1D("Hts0","Time-stamp;ts [usec]",2000,0,27e5);
  Hts[1]= new TH1D("Hts1","Time-stamp;ts [usec]",2000,91e9,97e9);



  //Rate hitograms
  TH1D * HrateFEE_ts[4];
  TH1D * HrateFEE_ch[4];
  TH1D * HrateADChigh_ts[1];
  TH1D * HrateInfo_ts[1];
  
  TH1I * HhitsADC[5];
  TH1I * HhitsInfo[4];
    
  TH2I * HtsFEE[3];
  TH2I * HtsInfo[1];
  TH2D * HtsCh[4];


  TH2I * HInfoFEE[4];

  double max_bin;
  if(n_last>0) max_bin= n_last;
  else max_bin= 1.e7;
  TH2I * HtsEvent[2];
  //HtsEvent[0]= new TH2I("HtsEvent0","Time-stamp vs entry;entry #;ts [usec]",200,0,max_bin,1000,0,27e5);
  HtsEvent[1]= new TH2I("HtsEvent1","Time-stamp vs entry;entry #;ts [usec]",500,0,max_bin,500,92e9,97e9);
  //sEvent[1]= new TH2I("HtsEvent1","Time-stamp vs entry;entry #;ts [usec]",500,0,max_bin,500,92.4e9,92.44e9);



  // variables for distribution of time-stamp differences
  double dts;
  double ts100_any[101];
  double ts100_adc[101];
  //  long long tsinide01;
  //  long long ts_side10;
  // long long ts_fee; 
  double ts_info= -1;
  int index_adc=0;
  int index_any=0;
  int index_prev;
  int last_side, this_side;
  int last_fee, this_fee;

  int step_back[9]={1,2,3,5,10,15,20,50,100};
  int steps;

  double ts;

  for(int i=0;i<101;i++){
    ts100_any[i]= -1;
    ts100_adc[i]= -1;
  }


  int Nooo=0;

  int info_code_prev, mod_id_prev, type_prev;


  //logfile
  ofstream logfile("outputLoop_R61_5.txt");

  time_t t_start; //, t_stop;

  TFile* input_file; 
  input_file = new TFile(inFile.data(),"read");
 
  if (input_file != 0){
    input_file->ls();

    TTree * input_tree;
    input_tree= (TTree*) input_file->Get("AIDA_sort");

    if(input_tree !=0) input_tree->Print();
    else {
      cout << "\n WARNING@ could not assign AIDA_sort Tree...." << endl;
      exit(0);
    }


    //tree from Converter step will data in a struct_entry_midas structure
    struct_entry_sort entry_1;

    input_tree->SetMakeClass(1);
    input_tree->SetBranchAddress("entry_sort",&entry_1,0);
    input_tree->SetBranchStatus("entry_sort",1);

    //number of data points in TTree
    long long n_entries;
    n_entries = input_tree->GetEntries();

    cout << "\nNumber of entries in input tree= " << n_entries << ", in file " << inFile << endl;
    logfile << "\nNumber of entries in input tree= " << n_entries << ", in file " << inFile << endl;
  


    //get run time... properly...
    long long time_first, time_last;

    time_first= 0;
    for(long long i=0; i<=100000; i++){
      input_tree->GetEntry(i);
      if(entry_1.sync_flag){
	time_first= entry_1.tm_stp;
	i=100000+1;
      }
    }
    if(time_first<=0){
      cout << "\n\n**** WARNING: Couldn't find Synchronized data in first 100K entries of file! ****\n" << endl;
      time_first=0;
    }
    input_tree->GetEntry(n_entries-1);
    time_last= entry_1.tm_stp;

    cout << "\n----------------------------------------------------------------------------"
    	 << "\n  Inititial time stamp= " <<time_first;
    cout << "\n  Lenght of run= "<<time_last-time_first <<" tm-stp= "<<(time_last-time_first)/1.e8 <<" sec"<<endl;




    //Define histograms that need to know run lenght....
    double ts_low, ts_up; //in usc
    double ts_sec;
    //    int ts_0;
    //in msec units!
    if(ts_0<0) ts_0 = time_first/100000; // 10x ns -> ms
    
    cout << " .... using ts_0= " << ts_0;

    //and this in usec units!
    ts_low= ts_0*1000.;
    ts_up= ts_low+20.e6;

    cout << "msec, ts_low= " << ts_low << " usec, ts_up= " << ts_up << " usec" << endl<<endl;

    int fee_index;
    bool b_ts_window;

    //Rate histograms

    int ts_0_sec= int(1.*time_first/1e8);
    //2 hrs, 10sec/bin
    HrateFEE_ts[0]= new TH1D("HrateFEE_ts0","Rate - ADClow(nnaida11);time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);
    HrateFEE_ts[1]= new TH1D("HrateFEE_ts1","Rate - ADClow(nnaida12);time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);
    HrateFEE_ts[2]= new TH1D("HrateFEE_ts2","Rate - ADClow(nnaida13);time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);
    HrateFEE_ts[3]= new TH1D("HrateFEE_ts3","Rate - ADClow(nnaida14);time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);

    HrateFEE_ch[0]= new TH1D("HrateFEE_ch0","Rate - ADClow(nnaida11);ch; rate [1/s];time-stamp [s]",64,0,64);
    HrateFEE_ch[1]= new TH1D("HrateFEE_ch1","Rate - ADClow(nnaida12);ch; rate [1/s];time-stamp [s]",64,0,64);
    HrateFEE_ch[2]= new TH1D("HrateFEE_ch2","Rate - ADClow(nnaida13);ch; rate [1/s];time-stamp [s]",64,0,64);
    HrateFEE_ch[3]= new TH1D("HrateFEE_ch3","Rate - ADClow(nnaida14);ch; rate [1/s];time-stamp [s]",64,0,64);

    HrateADChigh_ts[0]= new TH1D("HrateADChigh_ts0","Rate - ADChigh(any FEE);time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);
    HrateInfo_ts[0]= new TH1D("HrateInfo_ts0","Rate - Info Types;time-stamp [s];rate [1/s]",360,ts_0_sec,ts_0_sec+3600);

    //Info types for different FEEs (sum and vs time)
    HInfoFEE[0]= new TH2I("HInfoFEE0","Info Code vs FEE;Info Type;nnaida",16,0,16,4,11,15);
    HInfoFEE[1]= new TH2I("HInfoFEE1","Time-stamp vs FEE(Pause/Resume);time-stamp [s];nnaida",240,ts_0_sec,ts_0_sec+3600,4,11,15);
    HInfoFEE[2]= new TH2I("HInfoFEE2","Time-stamp vs FEE(SYNC100);time-stamp [s];nnaida",240,ts_0_sec,ts_0_sec+3600,4,11,15);
    HInfoFEE[3]= new TH2I("HInfoFEE3","Time-stamp vs FEE(Disc.);time-stamp [s];nnaida",240,ts_0_sec,ts_0_sec+3600,4,11,15);


    //hist vs time
    
    HhitsADC[0]= new TH1I("HhitsADC0","Rate [1/ms] - ADClow(nnaida11);time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsADC[1]= new TH1I("HhitsADC1","Rate [1/ms] - ADClow(nnaida12);time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsADC[2]= new TH1I("HhitsADC2","Rate [1/ms] - ADClow(nnaida13);time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsADC[3]= new TH1I("HhitsADC3","Rate [1/ms] - ADClow(nnaida14);time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsADC[4]= new TH1I("HhitsADC4","Rate [1/ms] - ADChigh;time-stamp [ms]",20000,ts_0,ts_0+20000);
    
    HhitsInfo[0]= new TH1I("HhitsInfo0","Rate [1/ms] - PAUSE/RESUME;time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsInfo[1]= new TH1I("HhitsInfo1","Rate [1/ms] - RESUME TS;time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsInfo[2]= new TH1I("HhitsInfo2","Rate [1/ms] - SYNC100;time-stamp [ms]",20000,ts_0,ts_0+20000);
    HhitsInfo[3]= new TH1I("HhitsInfo3","Rate [1/ms] - Discr. Data;time-stamp [ms]",20000,ts_0,ts_0+20000);


    HtsFEE[0]= new TH2I("HtsFEE0","Time-stamp vs FEE(ADClow);ts [ms];nnaida",1000,ts_0,ts_0+20000,4,11,15);
    HtsFEE[1]= new TH2I("HtsFEE1","Time-stamp vs FEE(SYNC100);ts [ms];nnaida",1000,ts_0,ts_0+20000,4,11,15);
    HtsFEE[2]= new TH2I("HtsFEE2","Time-stamp vs FEE(Pause/Res.);ts [ms];nnaida",1000,ts_0,ts_0+20000,8,11,15);

    //  HtsFEE[0]= new TH2I("HtsFEE0","Time-stamp vs FEE\# (ADClow);ts [msec];nnaida\# ",2000,ts_0,ts_0+20000,4,10.5,14.5);
    
    HtsInfo[0]= new TH2I("HtsInfo0","Time-stamp vs InfoCode;ts [ms];Info Type",1000,ts_0,ts_0+20000,16,0,16);
    
 
    HtsCh[0]= new TH2D("HtsCh0","Time-stamp vs Ch. (nnaida11);ts [ms];ch",5000,ts_0,ts_0+5000,64,0,64);
    HtsCh[1]= new TH2D("HtsCh1","Time-stamp vs Ch. (nnaida12);ts [ms];ch",5000,ts_0,ts_0+5000,64,0,64);
    HtsCh[2]= new TH2D("HtsCh2","Time-stamp vs Ch. (nnaida13);ts [ms];ch",5000,ts_0,ts_0+5000,64,0,64);
    HtsCh[3]= new TH2D("HtsCh3","Time-stamp vs Ch. (nnaida14);ts [ms];ch",5000,ts_0,ts_0+5000,64,0,64);




    t_start= time(0); //lets count how long it takes to loop through tree

    
    //now looping only over first 99 events, or up to n_entries, whatever is less
    if(n_last<1 || n_last>n_entries) n_last= n_entries;
   
    //  input_tree->GetEntry(0);

    for(long long i=0; i<n_last; i=i+downscale){
      //
      //  do stuff...
      //

      //    entry_0.tm_stp= entry_1.tm_stp;
      //    entry_0.type= entry_1.type;
      //    entry_0.info= entry_1.info;