#define __WORDSIZE 64

#include <iostream>
#include <fstream>
#include <string>
#include <evioUtil.hxx>
#include <unistd.h>
#include <vector>
#include <evioFileChannel.hxx>

#include <et.h>

using namespace std;
using namespace evio;

// root include files
#include "TApplication.h"  // needed to display canvas
#include "TSystem.h"
#include "TFile.h"
#include "TMath.h"
#include "TTree.h"
#include "TCanvas.h"
#include "TText.h" 
#include "TSpectrum.h"
#include "TPad.h"

#define RANDOMTRIG 100.

void analyzeEvent(evioDOMTree &evT);
void ConnectToET(const char* snam);
void mkpad(TPad **Pads) {

  Pads[0] = new TPad("Pads0","Title Pad",
                     0.05, 0.9, 0.97, 0.95, 4); 

  Pads[1] = new TPad("Pads1","Left Pad",
                     0.02, 0.02, 0.50, 0.89, 21); 

  Pads[2] = new TPad("Pads2","Right Pad",
                     0.52, 0.02, .98, 0.89, 21); 
  
}

void RateMonitor(void);

int EventCounter = 0;

unsigned long EVENTCounter;
int CDCOnly;
int ISCANCDC = 0;
int ISCANFDC = 0;
int evtCount = 0;
int DEBUG = 0;
int DEBUGG = 0;
int DEBUGGER = 0;
int VERBOSE = 0;
int RunNumber = 0;
int FInput=0;
int FAInput=0;
int FVInput=0;
int FNInput=0;

int TS3 = 0;
int Version = 0;
long TheEventNum;

uint64_t TRIGGERTIMES;
uint32_t TRIGGERTYPES;
uint32_t TRIGGER_MASK_GT;
uint32_t TRIGGER_MASK_FP;

uint64_t TOLDFP[100];
uint64_t TNEWFP[100];
uint64_t TOLDFP_INST[100];
uint64_t TNEWFP_INST[100];
double TCNTFP[100];
double TrateFP[100];
double TrateFP_INST[100];
double TrateFPSUM[100];
double TrateFPSUMCnt[100];

uint64_t TOLDGTP[100];
uint64_t TNEWGTP[100];
double TCNTGTP[100];
double TrateGTP[100];

double TrateGTP_INST[100];
double TrateGTPSUM[100];
double TrateGTPSUMCnt[100];

uint64_t TOLDGTP_S[100];
uint64_t TNEWGTP_S[100];
double TCNTGTP_S[100];
double TrateGTP_S[100];
double TrateGTPSUM_S[100];
double TrateGTPSUMCnt_S[100];
double TrateGTP_INST_S[100];


TCanvas *mymon;

int NEventsInBlock;
uint64_t EVENTNUMBER;
uint64_t EVTCounts;

int NTLines = 18; // Number of Trigger lines (GTP and FP)

uint64_t TIMER[3];

int ETSYSTEM;
uint32_t  BUFFER_SIZE;
et_sys_id sys_id;
et_att_id att_id;
et_stat_id sta_id;
bool et_connected;
int   ET_STATION_NEVENTS;
bool  ET_STATION_CREATE_BLOCKING;
int FROM_RAID = 1;

uint32_t ETBUFF[20000000];

void mangleData(uint32_t *ibuff, long int *TrigTim, uint32_t *TrigTyp);
void plotTheData();
void CountTriggers();

int TheRunNumber;
TPad *ThePads[3];
TText *List1[20];
TText *List2[20];
TText *List11[20];
TText *List22[20];
TText *List3[20];
TText *RunTitle;

int FIRST = 1;
int RMFIRST = 1;

void initText(){

  for (int k=0;k<20;k++){ 
    List1[k] = new TText(0.5,.5, "dummy");
    List11[k] = new TText(0.5,.5, "dummy");
    List2[k] = new TText(0.5,.5, "dummy");
    List22[k] = new TText(0.5,.5, "dummy");
    List3[k] = new TText(0.5,.5, "dummy");

  }
  RunTitle = new TText(0.1, 0.5, "dummy");

  List1[0]->SetText(0.1,0.95,"GTP TRIGGER RATES (Bit):");
  List2[0]->SetText(0.1,0.95,"FP  TRIGGER RATES (Bit):");
  List1[0]->SetTextSize(0.07);  
  List2[0]->SetTextSize(0.07);  
  List1[0]->SetTextColor(4);
  List2[0]->SetTextColor(4);
  
  List1[1]->SetText(0.1,0.91,"   (bit # start counting from 1!)");
  List1[1]->SetTextSize(0.045);  
  List2[1]->SetText(0.1,0.91,"   (bit # start counting from 1!)");
  List2[1]->SetTextSize(0.045);  
  
}



int main(int argc, char **argv) {

  if (argc<2){
    cout<<"useage:  trigmon [options]"<<endl;
    cout<<"         trigmon -h for help"<<endl;

    return 0;
  }

  BUFFER_SIZE = 80000000; // in bytes
  // prepare stuff for ET system in case its needed
  ETSYSTEM = 0;
  char ETSystemSource[256];
  TheRunNumber = 0;

  TIMER[0] = 0;
  TIMER[1] = 0;
  TIMER[2] = 0;
  EVTCounts = 0;
  EVENTCounter = 0;
  char ifnam[128];
  char filename[128];
  RunNumber = 0;
  char dirnam[128];
  Version = 0;
  CDCOnly = 1;

  for (int n=0;n<100;n++){
    TOLDGTP[n] = 0;
    TNEWGTP[n] = 0;
    TCNTGTP[n] = 0.;
    TrateGTP[n] = 0.;

    TOLDGTP_S[n] = 0;
    TNEWGTP_S[n] = 0;
    TCNTGTP_S[n] = 0.;
    TrateGTP_S[n] = 0.;

    TrateGTP[n] = 0.;
    TrateGTP_INST[n] = 0.;
    TrateGTPSUM[n] = 0.;
    TrateGTPSUMCnt[n] = 0.;
    TrateGTPSUM_S[n] = 0.;
    TrateGTPSUMCnt_S[n] = 0.;
    TrateGTP_INST_S[n] = 0.;

 
    TOLDFP[n] = 0;
    TNEWFP[n] = 0;
    TCNTFP[n] = 0.;
    TrateFP[n] = 0.;
    TrateFP_INST[n] = 0.;
    TOLDFP_INST[n] = 0;
    TNEWFP_INST[n] = 0;
    TrateFPSUM[n] = 0.;
    TrateFPSUMCnt[n] = 0.;
  }

  
  char Period[128];
  //sprintf(Period,"RunPeriod-2015-03");
  sprintf(Period,"RunPeriod-2018-08");
  char RaidDisk[128];
  sprintf(RaidDisk,"gluonraid1");

  for (int i=0; i<argc; i++){    
    if (!strcmp(argv[i],"-RAID2")){
      sprintf(RaidDisk,"gluonraid2");
    }
    if (!strcmp(argv[i],"-RAID3")){
      sprintf(RaidDisk,"gluonraid3");
    }
    if (!strcmp(argv[i],"-ET")){
	ETSYSTEM = 1;
      }
      if (!strcmp(argv[i],"-P1")){
	sprintf(Period,"RunPeriod-2014-10");
      }
      if (!strcmp(argv[i],"-P2")){
	sprintf(Period,"RunPeriod-2015-03" );
      }
      if (!strcmp(argv[i],"-P21")){
	sprintf(Period,"RunPeriod-2015-01");
      }
      if (!strcmp(argv[i],"-P3")){
	sprintf(Period,"RunPeriod-2015-06");
      }
      if (!strcmp(argv[i],"-P4")){
	sprintf(Period,"RunPeriod-2015-12");
      }
      if (!strcmp(argv[i],"-P5")){
	sprintf(Period,"RunPeriod-2016-02");
      }
      if (!strcmp(argv[i],"-P6")){
	sprintf(Period,"RunPeriod-2016-10");
      }
      if (!strcmp(argv[i],"-P7")){
	sprintf(Period,"RunPeriod-2017-01");
      }
      if (!strcmp(argv[i],"-P8")){
	sprintf(Period,"RunPeriod-2018-01");
      }
      if (!strcmp(argv[i],"-P9")){
	sprintf(Period,"RunPeriod-2018-08");
      }
      if (!strcmp(argv[i],"-R")){
	RunNumber = atoi(argv[++i]);
      }
      if (!strcmp(argv[i],"-V")){
        Version = atoi(argv[++i]);
      }
      if (!strcmp(argv[i],"-DB")){
        DEBUG = 1;
        DEBUGG = 1;
      }
      if (!strcmp(argv[i],"-DD")){
        DEBUGGER = 1;
      }
      if (!strcmp(argv[i],"-F")){
        FInput = 1;
	sprintf(filename,"%s",argv[++i]);
      }
      if (!strcmp(argv[i],"-FA")){
        FAInput = 1;
	sprintf(dirnam,"/%s/rawdata/active/%s/rawdata",RaidDisk,Period);
      }
      if (!strcmp(argv[i],"-FV")){
        FVInput = 1;
	sprintf(dirnam,"/%s/rawdata/volatile/%s/rawdata",RaidDisk,Period);
      }
      if (!strcmp(argv[i],"-FN")){
        FNInput = 1;
	sprintf(dirnam,"/gluex/Subsystems/TAGM/data");
      }
      if (!strcmp(argv[i],"-FR")){
        FROM_RAID = atoi(argv[++i]);
      }
      if (!strcmp(argv[i],"-VERB")){
        VERBOSE = atoi(argv[++i]); 
      }
      if ( (!strcmp(argv[i],"-h")) || (!strcmp(argv[i],"--help")) ){

	cout<<"usage:   trigmon [Options] "<<endl;

	cout<<endl;
	cout<<"   options:"<<endl;
	cout<<"      -P1 runperiod RunPeriod-2014-10"<<endl;
	cout<<"      -P2 runperiod RunPeriod-2015-03"<<endl;
	cout<<"      -P3 runperiod RunPeriod-2015-06"<<endl;
	cout<<"      -P4 runperiod RunPeriod-2015-12"<<endl;
	cout<<"      -P5 runperiod RunPeriod-2016-02"<<endl;
	cout<<"      -P6 runperiod RunPeriod-2016-10"<<endl;
	cout<<"      -P7 runperiod RunPeriod-2017-01"<<endl;
	cout<<"      -P7 runperiod RunPeriod-2018-01"<<endl;
	cout<<"      -P7 runperiod RunPeriod-2018-08 (default)"<<endl;
	cout<<"      -RAID1 gluonraid1 (default)"<<endl; 
	cout<<"      -RAID2 gluonraid2 "<<endl; 
	cout<<"      -RAID3 gluonraid3 "<<endl; 
	cout<<endl;
	cout<<"   options for reading files:"<<endl;
	cout<<"      -R # Runnumber"<<endl;
	cout<<"      -FV volatile "<<endl; 
	cout<<"      -FA active "<<endl; 
	cout<<"      -V # (file name appendix _###)"<<endl; 
	cout<<"      -RAID2 gluonraid2 (default is gluonraid1)"<<endl; 
	cout<<"      -F filename (for arbitrary files)"<<endl; 
	cout<<endl;
	cout<<"   options for reading from network:"<<endl;
	cout<<"      -ET use ET system of online data"<<endl;
	cout<<"      -FR #(1,0) (default 1, select ET system source)"<<endl;
	
	return 0;
      }
      
  }


  if (FAInput || FVInput){
    if (RunNumber<10000){
      sprintf(filename,"%s/Run00%d/hd_rawdata_%06d_%03d.evio",dirnam,RunNumber,RunNumber,Version);
    } else {
      sprintf(filename,"%s/Run0%d/hd_rawdata_%06d_%03d.evio",dirnam,RunNumber,RunNumber,Version);
    }
  }
  if (FNInput){
    sprintf(filename,"%s/tagm_calib_%d.0",dirnam,RunNumber);
  }



  TApplication theApp("App", &argc, argv);

  //  try 
  {
    
    evtCount = 0;
    int imod = 100;
    int OK = 1;

    // create evio file channel object using first arg as file name

    mymon = new TCanvas("mymon","DATA TRIGGER RATES",200,10,500,800);
    mymon->SetFillColor(18);
    mymon->Draw();
    mymon->cd();
    if (FIRST) { 
      mkpad(ThePads);
      FIRST = 0;
    }
    for (int k=0; k<3; k++){
      ThePads[k]->Draw();
    }
 

    if (ETSYSTEM){

      int ET_NOTOK = 1;
      int confail = 0;
      while (ET_NOTOK) {
	
	if (FROM_RAID) {
	  sprintf(ETSystemSource,"ET:/tmp/et_hdops_ERsoftROC:MON_TRIGMON:%s-ib:23921",RaidDisk);
	} else {
	  sprintf(ETSystemSource,"ET:/tmp/et_hdops_SEB0:MON_TRIGMON:%s-ib:23921",RaidDisk);
	  //sprintf(ETSystemSource,"ET:/tmp/et_sys_monitoring:MON_TRIGMON:172.19.5.47:11122");
	}

	cout<<"Attempt to connect to ET system with: "<<ETSystemSource<<endl;
	ConnectToET(ETSystemSource);
	
	if (!et_connected){
	  cout<<"Error failed to connect to ET system! stop right now...."<<endl; 
	  confail++;
	  if (confail>10){
	    return 100;
	  }
	  sleep(10);
	  
	} else{
	  ET_NOTOK = 0;
	}
	
      }
      
      long int TrigTim[10000];
      uint32_t TrigTyp[10000];
      et_event *pe=NULL;
      struct timespec timeout;
      uint32_t *et_buff=NULL;
      while (OK){
	
	timeout.tv_sec = 10;
	timeout.tv_nsec = 1;
	
	int err = et_event_get(sys_id, att_id, &pe, ET_TIMED , &timeout);
	
	if( err == ET_OK && pe==NULL){
	  cout << "  !!! ET returned no error, but event pointer is NULL!!!" << endl;
	  OK = 0;
	} else if (err != ET_OK){
	  OK = 0;
	}
	
	et_event_getdata(pe, (void**)&et_buff);
	if (et_buff == NULL){
	  cout<<"No DATA quit!"<<endl;
	  OK = 0;
	}
	
	if (OK){
	  try {
	    
	    mangleData(et_buff, TrigTim, TrigTyp);
	    
	  } catch (evioException e) {
	    cerr << "Event: "<<evtCount<<"  exception at eventTree()"<<endl;
	    cerr << endl << e.toString() << endl << endl << "Try to continue" <<endl;       
	    OK = 0;
	  }  
	  // Put ET event back since we're done with it
	  et_event_put(sys_id, att_id, pe);

	}

      }
      
    } else {
      
      sprintf(ifnam,"%s",filename);
      if (FILE *file = fopen(ifnam,"r")){
	fclose(file);
	//OK++;
	cout<<"File exists!"<<endl;
      } else {
	OK=0;
      }

      if (OK){
	OK=0;
	evtCount = 0;
	evioFileChannel EvOchan(ifnam,"r",BUFFER_SIZE);
	//evioFileChannel EvOchan(ifnam,"r");
	// open the file
	cout << "open data file " << ifnam <<endl;
	EvOchan.open();          // open evio file

	bool ReadBack  = EvOchan.read();
	while(ReadBack) {
	  
	  evtCount++;
	  EVENTCounter++;

	  imod--;

	  try {
	    
	    evioDOMTree eventTree(EvOchan);
	    analyzeEvent(eventTree);

	  } catch (evioException e) {
	    cerr << "Event: "<<evtCount<<"  exception at eventTree()"<<endl;
	    cerr << endl << e.toString() << endl << endl << "Try to continue" <<endl;       
	  }
	  
	  ReadBack = EvOchan.read();
	  
	} // end looping over events
	EvOchan.close();
      }

    } // ok

  } //try

} // end of main


void analyzeEvent(evioDOMTree &eventTree) {
  
  evioDOMNodeListP bankList2 = eventTree.getNodeList(typeIs<uint64_t>());
  evioDOMNodeList::iterator iter = bankList2->begin();

  //
  const uint64_t *run_number_and_type = NULL;

  for(; iter!=bankList2->end(); iter++){
    //cout<<"uint64_t loop"<<endl;
    evioDOMNodeP bankPtr = *iter;
    evioDOMNodeP physics_event_built_trigger_bank = bankPtr->getParent();
    if(physics_event_built_trigger_bank == NULL) continue;
    uint32_t tag = physics_event_built_trigger_bank->tag;
    const vector<uint64_t> *vec;
    switch(tag){
    case 0xFF22:
    case 0xFF23:
    case 0xFF26:
    case 0xFF27:
      vec = bankPtr->getVector<uint64_t>();
      if(!vec) continue;
      if(vec->size()<1) continue;
      run_number_and_type = &((*vec)[vec->size()-1]);
      break;
    }
    if(run_number_and_type != NULL){
      TheRunNumber =  ((*vec)[vec->size()-1])>>32;
      EVENTNUMBER = ((*vec)[0]);
      int MEVENTS = vec->size()-2;
      NEventsInBlock = MEVENTS ;
      TheEventNum = EVENTNUMBER;
      EVTCounts += MEVENTS;
      //cout<< TheRunNumber<<"  "<<TheEventNum<<"  "<<MEVENTS<<" "<< EVTCounts<<endl;
    }
  }
  

  evioDOMNodeListP bankList = eventTree.getNodeList(typeIs<uint32_t>());
  evioDOMNodeList::iterator iterX = bankList->begin();

  for(; iterX!=bankList->end(); iterX++){
    //cout<<"uint32_t loop"<<endl;
    evioDOMNodeP bankPtr = *iterX;
    evioDOMNodeP physics_event_built_trigger_bank = bankPtr->getParent();
    if(physics_event_built_trigger_bank == NULL) continue;

    if (bankPtr->tag==1){
      const vector<uint32_t> *vec;
      vec = bankPtr->getVector<uint32_t>();
      int NEV = vec->size()/4;
      if (NEventsInBlock != NEV){
	cout<<"Error Event Number Miss Match In Block "<<endl;
	cout<<"Expected: "<<NEventsInBlock<<"    found: "<<NEV<<endl;  
      }
      for (int k=0; k<NEV; k++){
	uint64_t hi_t = (*vec)[k*4];
	uint64_t lo_t = (*vec)[k*4+1];
	TRIGGERTIMES = hi_t + (lo_t<<32);
	TRIGGER_MASK_GT = (*vec)[k*4+2];
	TRIGGER_MASK_FP = (*vec)[k*4+3];

	//cout<<TRIGGERTIMES<<endl;
	CountTriggers();

      }
    }
  }
}

void RateMonitor() {
  
  int NT = NTLines;
  char str1[128];

  if (RMFIRST){
    RMFIRST = 0;
    initText();
  }


  for (int k=0;k<NT;k++){
    sprintf(str1,"%02d     %6.2f kHz ",k+1,TrateGTP[k]);
    if (ETSYSTEM)
          sprintf(str1,"%02d     %6.2f kHz ",k+1,TrateGTP_INST[k]);
    List1[k+2]->SetText(0.05,0.88-(float)k*0.04, str1);
    List1[k+2]->SetTextSize(0.08);  
    List1[k+2]->SetTextColor(15);
    if ( TrateGTP[k]>0 ){
      List1[k+2]->SetTextColor(1);
    }

    sprintf(str1,"(%6.2f kHz)",TrateGTP_S[k]);
    if (ETSYSTEM)
      sprintf(str1,"%02d     %6.2f kHz ",k+1,TrateGTP_INST_S[k]);
    
    List11[k+2]->SetText(0.65,0.88-(float)k*0.04, str1);
    List11[k+2]->SetTextSize(0.05);  
    List11[k+2]->SetTextColor(15);
    if ( TrateGTP_S[k]>0 ){
      List11[k+2]->SetTextColor(1);
    }
    
    //cout<<k<<"   " << TrateGTP[k]<<endl;

    sprintf(str1,"%02d     %7.3f Hz ",k+1,TrateFP[k]*1000.);
    sprintf(str1,"(%7.3f Hz)", TrateFP_INST[k]*1000.);
    List2[k+2]->SetText(0.05,0.88-(float)k*0.04, str1);
    List2[k+2]->SetTextSize(0.08);  
    List2[k+2]->SetTextColor(15);
    if ( TrateFP[k]>0 ){
      List2[k+2]->SetTextColor(1);
    }
    List22[k+2]->SetText(0.65,0.88-(float)k*0.04, str1);
    List22[k+2]->SetTextSize(0.05);  
    List22[k+2]->SetTextColor(15);
    if ( TrateFP_INST[k]>0 ){
      List22[k+2]->SetTextColor(1);
    }
  }

  sprintf(str1,"FULL:  %6.2f kHz ",TrateGTP[99]);
  List3[0]->SetText(0.15,0.78-(float)NT*0.04, str1);
  List3[0]->SetTextSize(0.08);  
  List3[0]->SetTextColor(15);
  if ( TrateGTP[99]>0 ){
    List3[0]->SetTextColor(1);
  }
  
  
  char a[128]="%";
  sprintf(str1,"LT:      %6.1f  %s ",TrateFP_INST[11]/RANDOMTRIG*100000.,a);
  List3[1]->SetText(0.15,0.78-(float)(NT+1)*0.04, str1);
  List3[1]->SetTextSize(0.08);  
  List3[1]->SetTextColor(15);
  if ( TrateFP_INST[11]>0 ){
    List3[1]->SetTextColor(1);
  }
  

  char tit[128];
  sprintf(tit,"Run Number %d",TheRunNumber);
  RunTitle->SetText(0.3, 0.255,tit);
  RunTitle->SetTextColor(5);
  RunTitle->SetTextSize(0.6);  
  

  mymon->cd();
  
  ThePads[0]->cd();
  ThePads[0]->Clear();
  RunTitle->Draw();
  
  ThePads[1]->cd();
  ThePads[1]->Clear();
  List1[0]->Draw();
  List1[1]->Draw();
  for (int k=0;k<NT;k++){
    List1[k+2]->Draw();
    List11[k+2]->Draw();
  }
  List3[0]->Draw();
  List3[1]->Draw();
  gPad->Update();
  
  ThePads[2]->cd();
  ThePads[2]->Clear();
  List2[0]->Draw();
  List2[1]->Draw();
  for (int k=0;k<NT;k++){
    List2[k+2]->Draw();
    List22[k+2]->Draw();
  }
  gPad->Update();
  
}





void ConnectToET(const char* snam){
  
  vector<string> fields;
  string str(snam);
  size_t startpos=0, endpos=0;
  while((endpos = str.find(":", startpos)) != str.npos){
    size_t len = endpos-startpos;
    fields.push_back(len==0 ? "":str.substr(startpos, len));
    startpos = endpos+1;
  }
  if(startpos<str.length()) fields.push_back(str.substr(startpos, str.npos));
  
  string session = fields.size()>1 ? fields[1]:"";
  string station = fields.size()>2 ? fields[2]:"";
  string host    = fields.size()>3 ? fields[3]:"localhost";
  int port       = fields.size()>4 ? atoi(fields[4].c_str()):ET_SERVER_PORT;
  
  if(session == "") session = "none";
  if(station == "") station = "DANA";
  if(host    == "") host    = "localhost";
  string fname = session.at(0)=='/' ? session:(string("/tmp/et_sys_") + session);
  
  // Report to user what we're doing
  cout << " Opening ET system:" << endl;
  if(session!=fname) cout << "     session: " << session << endl;
  cout << "     station: " << station << endl;
  cout << " system file: " << fname   << endl;
  cout << "        host: " << host    << endl;
  if(port !=0) cout << "        port: " << port << endl;
  
  // connect to the ET system
  et_openconfig openconfig;
  et_open_config_init(&openconfig);
  
  et_open_config_setcast(openconfig, ET_DIRECT);
  et_open_config_setmode(openconfig, ET_HOST_AS_LOCAL); // ET_HOST_AS_LOCAL or ET_HOST_AS_REMOTE
  et_open_config_sethost(openconfig, host.c_str());
  et_open_config_setport(openconfig, ET_BROADCAST_PORT);
  if(port != 0)et_open_config_setserverport(openconfig, port);
  
  int err = et_open(&sys_id,fname.c_str(),openconfig);
  if(err != ET_OK){
    cerr << __FILE__<<":"<<__LINE__<<" Problem opening ET system"<<endl;
    cerr << et_perror(err);
    return;
  }
  
  // create station config in case no station exists
  et_statconfig et_station_config;
  et_station_config_init(&et_station_config);
  et_station_config_setblock(et_station_config, 
			     ET_STATION_CREATE_BLOCKING ? ET_STATION_BLOCKING:ET_STATION_NONBLOCKING);
  et_station_config_setselect(et_station_config,ET_STATION_SELECT_ALL);
  et_station_config_setuser(et_station_config,ET_STATION_USER_MULTI);
  et_station_config_setrestore(et_station_config,ET_STATION_RESTORE_OUT);
  et_station_config_setcue(et_station_config,ET_STATION_NEVENTS);
  et_station_config_setprescale(et_station_config,1);
  cout<<"ET station configured\n";
  
  // create station if not already created
  int status=et_station_create(sys_id,&sta_id,station.c_str(),et_station_config);
  if((status!=ET_OK)&&(status!=ET_ERROR_EXISTS)) { 
    et_close(sys_id);
    cerr << "Unable to create station " << station << endl;
    cerr << et_perror(status);
    
    // Check that the number of events in the ET system is not
    // less than the number of events we specified for the station CUE.
    int Nevents = 0;
    et_system_getnumevents(sys_id, &Nevents);
    if(Nevents <= ET_STATION_NEVENTS){
      cerr << "NOTE: The number of events specified for the station cue is equal to" << endl;
      cerr << "or greater than the number of events in the entire ET system:" << endl;
      cerr << endl;
      cerr << "     " << ET_STATION_NEVENTS << " >= " << Nevents << endl;
      cerr << endl;
      cerr << "Try re-running with: " << endl;
      cerr << endl;
      cerr << "      -PEVIO:ET_STATION_NEVENTS=" << (Nevents+1)/2 << endl;
      cerr << endl; 
    }
    return;
  }
  if(status==ET_ERROR_EXISTS){
    cout << " Using existing ET station " << station << endl;
  }else{
    cout << " ET station " << station << " created\n";
  }
  
  // Attach to the ET station
  status=et_station_attach(sys_id,sta_id,&att_id);
  if(status!=ET_OK) {
    et_close(sys_id);
    cerr << "Unable to attach to station " << station << endl;
    return;
  }
  
  cout << "...now connected to ET system: " << fname 
       << ",   station: " << station << " (station id=" << sta_id << ", attach id=" << att_id <<")" << endl;
  
  et_connected = true;    
  // chan = new evioETChannel(sys_id, att_id);
  
  // Make sure the size of event buffers we will allocate are at least as big
  // as the event size used in the ET system
  size_t eventsize;
  et_system_geteventsize(sys_id, &eventsize);
  if((uint32_t)eventsize > BUFFER_SIZE){
    cout<<" Events in ET system are larger than currently set buffer size:"<<endl;
    cout<<" "<<eventsize<<" > "<<BUFFER_SIZE<<endl;
    cout<<" Setting BUFFER_SIZE to "<<eventsize<<endl;
    BUFFER_SIZE = (uint32_t)eventsize;
  }else{
    cout<<" ET system event size:"<<eventsize<<"  EVIO BUFFER_SIZE:"<<BUFFER_SIZE<<endl;
  }

}



void mangleData(uint32_t ibuff[], long int TrigTim[], uint32_t TrigTyp[]){

  bool swap_needed = false;
  uint32_t magic = ibuff[7];
  switch(magic){
  case 0xc0da0100:  swap_needed = false;  break;
  case 0x0001dac0:  swap_needed = true;  break;
  default:
    cout << "EVIO magic word not present!" << endl;
    return ;
  }
  
  uint32_t len = ibuff[0];
  
  uint32_t ALLEVENTS = ibuff[3];
  
  if (swap_needed){
    len = EVIO_SWAP32(len);
    ALLEVENTS = EVIO_SWAP32(ALLEVENTS);
  }
  
  //cout<<"Payload Banks: "<<ALLEVENTS<<endl;

  uint32_t RecLenOffset = 0;
  for (unsigned int PLB=0; PLB<ALLEVENTS; PLB++){

    // offset 8 to first Payload Bank 
    uint32_t RecLen = ibuff[8+RecLenOffset];
    uint32_t Ns[8];
    uint32_t Len0 = 3;
    for (int k=0; k<4; k++)
      Ns[k] = ibuff[9+RecLenOffset + k];

    if (swap_needed){
      RecLen =  EVIO_SWAP32(RecLen);
      for (int k=0; k<4; k++)
	Ns[k] =  EVIO_SWAP32(Ns[k]);
    }

    uint32_t Len1 = Ns[3]&(0xFFFF);
    int NROCS = 0;
    if ((Ns[2]>>20) == 0xFF2){
      NROCS = Ns[2] & 0xFF;
    }

    if (NROCS>64){
      cout<<"FUCK! NROCS!!!! "<<Ns[2]<<endl;
      break;
    }

    uint32_t RUN = ibuff[9+RecLenOffset + Len1 + Len0 -1];

    uint32_t NEXT = ibuff[9+RecLenOffset + Len1 + Len0];
    if (swap_needed){
      RUN = EVIO_SWAP32(RUN);
      NEXT = EVIO_SWAP32(NEXT);
    }
    TheRunNumber = RUN;
    
    uint32_t Len2 = NEXT & 0xFFFF;
    uint32_t Hs[64];
    uint32_t LEN[64];
    int ROCID[64];
    int n;
    uint32_t off = 0;
    for (n=0; n<NROCS; n++) {
      off = 0;
      for (int s=0;s<n;s++){
	off += LEN[s];
      }
      Hs[n] = ibuff[9+RecLenOffset + Len1 + Len0 + Len2 + off];
      if (swap_needed){
	Hs[n] = EVIO_SWAP32(Hs[n]);
      }
      LEN[n] = (Hs[n] & 0xFFFF) + 1;    
      ROCID[n] = (Hs[n]>>24) & 0xFF;
      if (ROCID[n] == 1){
	break;
      }

    }

    if (ROCID[n] == 1){
      // this is the trigger supervisor ROC
      int NEVENTS = LEN[n]/4;
      uint32_t w[4];
      int idx = 9+RecLenOffset + Len1 + Len0 + Len2 + off + 1;

      for (int i=0; i<NEVENTS; i++){
	for (int j=0;j<4;j++) {
	  w[j] = ibuff[idx + i*4 + j];
	}
	if (swap_needed){
	  for (int j=0;j<4;j++) {
	    w[j] = EVIO_SWAP32(w[j]);
	  }
	}
	
	uint64_t hi_t = w[0];
	uint64_t lo_t = w[1];
	TRIGGERTIMES = hi_t + (lo_t<<32);
	TRIGGER_MASK_GT = w[2];
	TRIGGER_MASK_FP = w[3];
	
	CountTriggers();
	
      } // this is ROC1 data end
      
    }
    
    RecLenOffset += RecLen+1;    
  }

  if ((TheRunNumber)<10000000){
    plotTheData();
  }

}

void CountTriggers(){

  if (TIMER[0] == 0){
    TIMER[0] = TRIGGERTIMES;
  }
  TIMER[1] = TRIGGERTIMES;
  

  //cout<<TRIGGERTIMES<<hex<<"   0x"<<TRIGGER_MASK_GT<<"   0x"<<TRIGGER_MASK_FP<<dec<<endl;

  int bit1[100];
  int NBits1 = 0;
  
  int bit1_S[100];
  int NBits1_S = 0;
  if (TRIGGER_MASK_GT>0){
    unsigned int val = TRIGGER_MASK_GT;
    for (int nn=0; nn<32; nn++){
      bit1[nn] = -1;
      if (val & (1<<nn)){
	bit1[NBits1] = nn;
	NBits1++;
      }
      bit1_S[nn] = -1;
      if (val == (uint32_t) (1<<nn) ){
	bit1_S[NBits1_S] = nn;
	NBits1_S++;	      
      }
    }  
  }
  int bit2[100];
  int NBits2 = 0;
  if (TRIGGER_MASK_FP>0){
    unsigned int val = TRIGGER_MASK_FP;
    for (int nn=0; nn<32; nn++){
      bit2[nn] = -1;
      if (val & (1<<nn)){
	bit2[NBits2] = nn;
	NBits2++;
      }
    }
  }
  
  if (NBits1){ // GTP triggers
    for (int nn=0; nn<NBits1; nn++){
      TNEWGTP[bit1[nn]] = TRIGGERTIMES;
      TCNTGTP[bit1[nn]] += 1.;
      if (TOLDGTP[bit1[nn]] == 0){
	TOLDGTP[bit1[nn]] = TNEWGTP[bit1[nn]];
      }
    }
    TNEWGTP[99] =  TRIGGERTIMES; // COUNT all TRIGGERS
    TCNTGTP[99] += 1.;
    if (TOLDGTP[99] == 0){
      TOLDGTP[99] = TNEWGTP[99];
    }
    
  }
  if (NBits1_S){ // SINGLE GTP Trigger
    for (int nn=0; nn<NBits1_S; nn++){
      TNEWGTP_S[bit1_S[nn]] = TRIGGERTIMES;
      TCNTGTP_S[bit1_S[nn]] += 1.;
      if (TOLDGTP_S[bit1_S[nn]] == 0){
	TOLDGTP_S[bit1_S[nn]] = TNEWGTP_S[bit1_S[nn]];
      }
    }
  } 
  
  if (NBits2){ // FP TRIGGER
    for (int nn=0; nn<NBits2; nn++){
      TNEWFP[bit2[nn]] = TRIGGERTIMES;
      TNEWFP_INST[bit2[nn]] = TRIGGERTIMES;
      TCNTFP[bit2[nn]] += 1.; 
      if (TOLDFP[bit2[nn]] == 0){
	TOLDFP[bit2[nn]] = TNEWFP[bit2[nn]];
	TOLDFP_INST[bit2[nn]] = TNEWFP[bit2[nn]];
      } else { // instantaneous rates for FP triggers
	double dt = (TNEWFP_INST[bit2[nn]]-TOLDFP_INST[bit2[nn]])*4./1000000.;
	if (dt>0){
	  TrateFPSUM[bit2[nn]] += 1./dt;
	  TrateFPSUMCnt[bit2[nn]] += 1.;
	  TOLDFP_INST[bit2[nn]] = TNEWFP_INST[bit2[nn]];	      
	}
      }
    }

    if (NBits1==0){
      TNEWGTP[99] =  TRIGGERTIMES; // COUNT All TRIGGERS
      TCNTGTP[99] += 1.;
      if (TOLDGTP[99] == 0){
	TOLDGTP[99] = TNEWGTP[99];
      }
    }
  }

  
  if (!ETSYSTEM){
    plotTheData();
  }
  

}
  

void plotTheData(){
  
  double DT = ((double)(TIMER[1] - TIMER[0])) *4./1000000. ;  // Time laps in ms
  
  //if (!(int(DT)%2000)){ // a little more than 1 s
  //if (DT>2000.){ // a little more than 1 s
    if ((ETSYSTEM) || (DT>2000.)) { // a little more than 1 s
    EVTCounts = 0;
    int NT = NTLines;
    
    for (int n=0;n<NT;n++){
      if  (TCNTGTP[n]>0) {
	double dt = (TNEWGTP[n]-TOLDGTP[n])*4./1000000.;
	if (dt>0){
	  TrateGTP[n] = TCNTGTP[n]/DT;
	  TrateGTPSUM[n] += TCNTGTP[n]/DT;
	  TrateGTPSUMCnt[n] += 1.;
	  TrateGTP_INST[n] = TrateGTPSUM[n]/TrateGTPSUMCnt[n];
	  //TrateGTP[n] = TCNTGTP[n]/dt;
	}
      } else {
	TrateGTP[n] = 0; 
      }
      //cout<<n<<"   "<<TrateGTP[n]<<endl;
    }
    // Overall trigger rate:
    if  (TCNTGTP[99]>0) {
      double dt = (TNEWGTP[99]-TOLDGTP[99])*4./1000000.;
      if (dt>0){
	TrateGTP[99] = TCNTGTP[99]/DT;
	//TrateGTP[99] = TCNTGTP[99]/dt;
      }
    } else {
      TrateGTP[99] = 0; 
    }
    
    
    for (int n=0;n<NT;n++){
      if  (TCNTGTP_S[n]>0) {
	double dt = (TNEWGTP_S[n]-TOLDGTP_S[n])*4./1000000.;
	if (dt>0){
	  TrateGTP_S[n] = TCNTGTP_S[n]/DT;
	  TrateGTPSUM_S[n] += TCNTGTP[n]/DT;
	  TrateGTPSUMCnt_S[n] += 1.;
	  TrateGTP_INST_S[n] = TrateGTPSUM_S[n]/TrateGTPSUMCnt_S[n];
	  //TrateGTP_S[n] = TCNTGTP_S[n]/dt;
	}
      } else {
	TrateGTP_S[n] = 0; 
      }
    }
    
    for (int n=0;n<NT;n++){
      if  (TCNTFP[n]>0) {
	double dt = (TNEWFP[n]-TOLDFP[n])*4./1000000.;	    
	if (dt>0){
	  TrateFP[n] = TCNTFP[n]/DT;
	  //TrateFP[n] = TCNTFP[n]/dt;
	} else {
	  TrateFP[n] = 0.;
	}
      }
      if (TrateFPSUMCnt[n]>0){
	TrateFP_INST[n] = TrateFPSUM[n] / TrateFPSUMCnt[n];
      } else {
	TrateFP_INST[n] = 0.;
      }
      
    }
    
    RateMonitor();


    TIMER[0] = 0;
    TIMER[1] = 0;
    
    for (int n=0;n<100;n++){
      TOLDGTP[n] = 0;
      TNEWGTP[n] = 0;
      TCNTGTP[n] = 0.;
      TOLDGTP_S[n] = 0;
      TNEWGTP_S[n] = 0;
      TCNTGTP_S[n] = 0.;

      if (TrateGTPSUMCnt[n] > 10){
	TrateGTPSUMCnt[n] = 0;
	TrateGTPSUM[n] = 0;
      }

      if (TrateGTPSUMCnt_S[n] > 10){
	TrateGTPSUMCnt_S[n] = 0;
	TrateGTPSUM_S[n] = 0;
      }

    }
    
    for (int n=0;n<100;n++){
      TOLDFP[n] = 0;
      TNEWFP[n] = 0;
      TCNTFP[n] = 0.;
      TrateFPSUMCnt[n] = 0;
      TrateFPSUM[n] = 0; 
    }


  }     
  return;
}