/*

read adc125 data with random trigger check if a channel is
over a given threshold and write those channels with all samples
to data file

adctest2.cc new feature use ccdb_online data base to retreive DAC values
and determine sparsification values.

*/

#include <iostream>
#include <fstream>

#include "adctest2.h"

extern "C"{
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <jvme.h>
#include <tiLib.h>
#include <fa125Lib.h>
#include "math.h"
#include "time.h"   
#include "sys/types.h"
#include <unistd.h>

  extern int nfa125;
  extern int fa125A32Base;
  extern int tiA32Base;
  
  DMA_MEM_ID vmeIN,vmeOUT;
  extern unsigned int *dma_dabufp;
  
}

//UINT32 F125DATA[40000];

#define FA125_ADDR (5<<19)
#define TI_ADDR (21<<19)

ofstream OUTF;
ofstream OUTFPed;

void myReadoutCode();
void mkpedestals();

unsigned int START;
int HOSTROC = 0;
int NADCSAMPLES = 100;
int THRESHOLD = 300;
int NADCS = 1;
int TIMETEST = 0;
int NEVENT = 0;
int RAWDATA = 0;
int DEBUG =0;
int DEBUGGER = 0;
int NOSPARS = 0;
int NODAC = 0;
int DOPEDS = 10000; 
unsigned int timelaps = 0;

unsigned int Pedestal[20][72];
int ADCSamples[20][72][200];
int OT[20][72];
float Ped[20][72];
int EventCounter = 0;


int Thresholds[20][72];

float PedSum[20][72];
float PedSum2[20][72];
float PedSumCntr[20][72];

int PedestalCounter = 0;

int DAC_Values[20][72];

int ERRORCounter = 0;
int ERRORLOG = 10000;

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

  int Nevents = 1000;
  int iFlag;
  int stat;
  char ofnam[128];
  char ofnamped[128];
  char CrateName[128] = "One";
  char ifnam[128];


  char DataDir[128] = "/gluonraid1/Users/zihlmann/FDCDATA";

  
  printf("\nJLAB f125ADC pedestal Tests\n");
  printf("----------------------------\n");
  
  int k=0;
  int SLOT=3;
  int TIMING = 30;
  if (argc<2) {
    cout<<argc<<endl;
    cout<<"usage: pulserTestNew [Options]"<<endl;
    cout<<"       -S  #        Slot number of first ADC to be used in test (default 3)"<<endl;
    cout<<"       -T  #        Trigger timing offset default is 30"<<endl;
    cout<<"       -N  #        Number of triggers default is 1000"<<endl;
    cout<<"       -X  #        Number of samples to read (default 100)"<<endl;
    cout<<"       -TH #        Signal THRESHOLD (default 300)"<<endl;
    cout<<"       -A  #        All # ADCs from slot 3 to 3+# (default 1)"<<endl;
    cout<<"       -C  string   Crate Name (default \"One\")"<<endl;
    cout<<"       -TT          Timing Test" <<endl;
    cout<<"       -R           write out RAWDATA" <<endl;
    cout<<"       -D           write out DEBUG info" <<endl;
    cout<<"       -DD          write out DEBUGGGER info" <<endl;
    cout<<"       -NS          do not read sparcification files" <<endl;
    cout<<"       -ND          do not read DAC values set all to 0x8000" <<endl;
    cout<<"       -DP #        do pedestals every # event (default 10000)" <<endl;
    return 0;
  }

  for (k=0;k<argc;k++){
    
    if (!strcmp(argv[k],"-S")){
      SLOT = atoi(argv[k+1]);
      k++;
    }
    
    if (!strcmp(argv[k],"-T")){
      TIMING = atoi(argv[k+1]);
      k++;
    }
    
    if (!strcmp(argv[k],"-N")){
      Nevents = atoi(argv[k+1]);
      k++;
    }
    
    if (!strcmp(argv[k],"-X")){
      NADCSAMPLES = atoi(argv[k+1]);
      k++;
      if (NADCSAMPLES%2){
	NADCSAMPLES +=1;
      }
    }
    if (!strcmp(argv[k],"-TH")){
      THRESHOLD = atoi(argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-A")){
      NADCS = atoi(argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-DP")){
      DOPEDS = atoi(argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-C")){
      sprintf(CrateName,"%s",argv[k+1]);
      k++;
    }
    if (!strcmp(argv[k],"-TT")){
      TIMETEST = 1;
    }
    if (!strcmp(argv[k],"-R")){
      RAWDATA = 1;
    }
    if (!strcmp(argv[k],"-D")){
      DEBUG = 1;
    }
    if (!strcmp(argv[k],"-DD")){
      DEBUGGER = 1;
    }
    if (!strcmp(argv[k],"-NS")){
      NOSPARS = 1;
    }
    
    if (!strcmp(argv[k],"-ND")){
      NODAC = 1;
    }

    if (!strcmp(argv[k],"-h")){
      cout<<"usage: pulserTestNew [Options]"<<endl;
      cout<<"       -S  #        Slot number of first ADC to be used in test (default 3)"<<endl;
      cout<<"       -T  #        Trigger timing offset default is 30"<<endl;
      cout<<"       -N  #        Number of triggers default is 1000"<<endl;
      cout<<"       -X  #        Number of samples to read (default 100)"<<endl;
      cout<<"       -TH #        Signal THRESHOLD (default 300)"<<endl;
      cout<<"       -A  #        All # ADCs from slot 3 to 3+# (default 1)"<<endl;
      cout<<"       -C  string   Crate Name (default \"One\")"<<endl;
      cout<<"       -TT          Timing Test" <<endl;
      cout<<"       -R           write out RAWDATA" <<endl;
      cout<<"       -D           write out DEBUG info" <<endl;
      cout<<"       -DD          write out DEBUGGER info" <<endl;
      cout<<"       -NS          do not read sparcification files" <<endl;
      cout<<"       -ND          do not read DAC values set all to 0x8000" <<endl;
      cout<<"       -DP #        do pedestals every # event (default 10000)" <<endl;
      return 0;
    }
    
  }

  for (int n=0;n<20;n++){
    for (int k=0;k<72;k++){
      PedSum[n][k] = 0.;
      PedSum2[n][k] = 0.;
      PedSumCntr[n][k] = 0.;
    }
  }

  if (NADCS==1){
    sprintf(ofnam,"%s/adcdata_%s_slot%d.dat",DataDir,CrateName,SLOT); 
    sprintf(ofnamped,"%s/adcdata_%s_slot%d_pedestals.dat",DataDir,CrateName,SLOT); 
  } else {
    sprintf(ofnam,"%s/adcdata_%s_ALLslots.dat",DataDir,CrateName); 
    sprintf(ofnamped,"%s/adcdata_%s_ALLslots_pedestals.dat",DataDir,CrateName); 
  }


  if(vmeOpenDefaultWindows() != OK) {
    cout<<"vmeOpenDefaultWindows failed. Terminate right here."<<endl;
    return 0;
  } 


  // load sparcification data
  char hnam[128];
  gethostname(hnam,128);
  char s[128];
  strncpy(s,&hnam[6],128);
  HOSTROC = atoi(s);
  cout<<" HOST "<<s<<endl;


  int db =  GetDACfromdatabase(HOSTROC);

  if (NOSPARS) { 
    for (int n=0;n<NADCS;n++){
          for (int k=0;k<72;k++){	    
	    Thresholds[n][k] = 100; // default thresholds  
	  }
    }
  }
  if (NODAC) { 
    for (int n=0;n<NADCS;n++){
      for (int k=0;k<72;k++){	    
	DAC_Values[n][k] = 0x8000; // default daqvalues
      }
    }
  }
  
  if (DEBUG){
  //if (1){
    cout<<"TEST THRESHOLDS of first 5 SLOTS"<<endl;
    for (int k=0;k<NADCS;k++){
      for (int j=0;j<72;j++){
	cout<<k<<"  "<<j<<"  "<<Thresholds[k][j]<<"   "
	    <<DAC_Values[k][j]<<endl;
      }
    }
  }


  vmeDmaConfig(2,2,1);
  /* INIT dmaPList */
  dmaPFreeAll();
  vmeIN  = dmaPCreate("vmeIN",4*72*104*17+100,10,0);
  vmeOUT = dmaPCreate("vmeOUT",0,0,0);
  dmaPStatsAll();
  dmaPReInitAll();
    
  tiInit(TI_ADDR, TI_READOUT_EXT_POLL, 0);
  tiCheckAddresses();
  tiDisableDataReadout();  // do not read out TI
  tiDisableA32();          // do not read out TI   
  
  tiLoadTriggerTable(0);
  tiSetTriggerHoldoff(1,4,0);
  tiSetTriggerHoldoff(2,4,0);

  tiSetPrescale(0);
  tiSetBlockLevel(1);

  tiSetTriggerSource(TI_TRIGGER_PULSER);
  tiEnableTSInput(0x1);

  tiSetBusySource(TI_BUSY_LOOPBACK, 1);
  tiSetBlockBufferLevel(1);
  tiSetFiberDelay(1,2);
  tiSetSyncDelayWidth(1, 0x3f, 1);
  
  // setup clock, etc for single-crate system only
  tiClockReset();
  taskDelay(1);
  tiTrigLinkReset();
  taskDelay(1);
  tiEnableVXSSignals();
  taskDelay(1);
  tiSyncReset();
  taskDelay(1);
  tiStatus();

  //tiSetOutputPort(1, 0, 0, 0);
  // tiClockResync();
  // tiClockReset();
  // tiSyncReset();
   
  extern unsigned int fa125AddrList[FA125_MAX_BOARDS];
  
  if (NADCS==1){
    fa125AddrList[0] = (SLOT<<19);  // adc in slot SLOT
  } else {
    int offset = 0;
    for (int k=0;k<NADCS;k++){
      fa125AddrList[k] = ((k+SLOT+offset)<<19);
      if (k+SLOT==10){
	offset = 2;
      }
    }
  }
  
  iFlag  = (1<<17); /* use fa125AddrList */
  /*
    bits 2-1:  defines Trigger source
    (0) 0 0  VXS (P0)
    (1) 0 1  Internal Timer
    (2) 1 0  Internal Multiplicity Sum
    (3) 1 1  P2 Connector (Backplane)
    bit    3:  NOT USED WITH THIS FIRMWARE VERSION
    bits 5-4:  defines Clock Source
    (0) 0 0  P2 Connector (Backplane)
    (1) 0 1  VXS (P0)
    (2) 1 0  Internal 125MHz Clock
  */
  iFlag |= (0<<1);  /* Trigger Source */
  iFlag |= (1<<4);  /* Clock Source */
  
  stat = fa125Init(0, 0, NADCS, iFlag);
  if (stat != OK) {
    cout<<"ERROR: fa125Init failed, stop right here!!!"<<endl;
    return 0;
  }
  
  // the following needs to be done after initializing
  // only then fa125ScanMask() will work properly
  
  sdInit();
  sdSetActiveVmeSlots( fa125ScanMask());
  sdStatus();
  
  for (int k=0;k<NADCS;k++){
    int S = fa125Slot(k);
    fa125PowerOn(S);
    cout<<"Set DAC values for all channels in ADC slot "<<S<<endl;
    for(int ichan=0; ichan<72; ichan++) {
      if (!NODAC){
	fa125SetOffset(S,ichan,DAC_Values[k][ichan]);
      } else{
	fa125SetOffset(S,ichan,0x8000);
      }
    }
    
    fa125PrintTemps(S);
    //fa125Clear(S);  
    fa125Reset(S,0);
    fa125Enable(S);
    //fa125Status(S);
  }
  for (int k=0;k<NADCS;k++){
    int S = fa125Slot(k);
    fa125Status(S);
  }

  
  //  tiIntConnect(TI_INT_VEC, myReadoutCode, tiIntArg);
  //  TI_INT_VEC =  0xec defined in tiLib.h
  //  tiIntArg = 0 defined in tiLib.c
  tiIntConnect(TI_INT_VEC, myReadoutCode, 0);

  printf("Hit return to start Triggers...\n");
  getchar();
  
  /* Enable the TI and clear the trigger counter */
  tiIntEnable(0);
  tiStatus();
  fa125Status(0);
  
  if (!TIMETEST){
    OUTF.open(ofnam,ios::out);
    OUTFPed.open(ofnamped,ios::out);
  }
  
  cout<<clock()<<"   START OF LOOP"<<endl; 
  START = clock();
  
  tiSetRandomTrigger(1,0x7);
  
  while (tiGetIntCount()<Nevents){
    
    //cout<<"Event : "<<tiGetIntCount()<<endl;
    
  }// end of loop overall events
  tiStatus();
  fa125Status(0);

  tiIntDisable();
  tiIntDisconnect(); 
  
  for (int k=0;k<NADCS;k++){
    int S = fa125Slot(k);
    fa125PrintTemps(S);
    fa125PowerOff(S);
  }
  
  cout<<clock()<<"    END OF LOOP"<<endl;    
  unsigned int ENDL = clock();
  
  //tiIntDisable();
  cout<<"TOTAL TIME: "<<(ENDL-START)/CLOCKS_PER_SEC<<" seconds"<<endl;
    
  vmeCloseDefaultWindows();      

  if (!TIMETEST){
    OUTF.close();
    mkpedestals();
    OUTFPed.close();
  }

  cout<<"Total time used: "<<timelaps<<" s"<<endl;


  return 0;
}

//!!!!!!!!!!!!!!!!!

void myReadoutCode(){

  DMANODE *outEvent;

  
  memset(OT,0,20*72*4);
  int iread = 0;
  int timeout = 100000;
  int dCnt = 0;
  int ReadyCode = 0;

  EventCounter++;

  for(iread=0; iread<timeout; iread++) {
    if(fa125GBready()==fa125ScanMask())
      break;
  }

  if(iread==timeout) {
    ERRORCounter++;
    if (ERRORCounter<100){
      cout<<"ADC read TIMEOUT event: "<<EventCounter<<"     Return Mask is "
	  << hex << ReadyCode<<"  should be "<< fa125ScanMask()<<dec<<endl;
    } else if (ERRORCounter%ERRORLOG){
      cout<<"ADC read TIMEOUT event: "<<EventCounter<<"     Return Mask is "
	  << hex<<ReadyCode<<"  should be "<< fa125ScanMask()<<dec<<endl;
      ERRORLOG *= 10;
    }
    fa125ResetToken(fa125Slot(0));
    return ;
  }
  else {
    GETEVENT(vmeIN,EventCounter);
    dCnt = fa125ReadBlock(0,(volatile UINT32 *)dma_dabufp, 0xf000, 0x2);
    if(dCnt<=0) {
      fa125ResetToken(fa125Slot(0));
      if (ERRORCounter<100){
	printf("No fa125 data or error.  dCnt = %d\n",dCnt);
      } else if (ERRORCounter%ERRORLOG){
	ERRORLOG *=10;
	printf("No fa125 data or error.  dCnt = %d\n",dCnt);
      }
      return;
    } else {
      dma_dabufp += dCnt;
    }
  }
  fa125ResetToken(fa125Slot(0));


  //OUTF<<EventCounter<< "    Event Size: "<<dCnt<<endl;

  PUTEVENT(vmeOUT);
  outEvent = dmaPGetItem(vmeOUT);
  int eventLen = outEvent->length;

  int SLOTNUM = 0;
  int EVENT = -1;
  int CHANNEL = -1;
  int WSize = 0;
  int idx = 0;
  int pedcnt = 0;
  float adc1, adc2;
  int DATAReady=0;
  int EventsInBlock=0;
  int TriggerTime_1=0;
  int TriggerTime_2=0;
  int TrueSize=0;

  if (DEBUGGER){
    OUTF<<"EVENT "<<EventCounter<<"           Event Length: "<<eventLen<<endl; 
  }

  DEBUG = 0;
  if ((eventLen<(NADCS*3866-40)) || (eventLen>(NADCS*3866+40))){
    //if ((eventLen<7730) || (eventLen>7800)){
    //if ((eventLen<950) || (eventLen>970)){
    OUTF<<"EVENT "<<EventCounter<<"           Event Length: "<<eventLen<<endl; 
    DEBUG = 1 ;
  } 


  int Indx = 0;

  //if ((EventCounter==56)|| (EventCounter==1)|| (EventCounter==111)|| 
  //    (EventCounter==167)){
  //  DEBUG = 1;
  //} else {
  //  DEBUG = 0;
  //}
 

  for (Indx=0;Indx<eventLen;Indx++){

    unsigned int data = (unsigned int)LSWAP(outEvent->data[Indx]);

    if (DEBUG)
      OUTF<<Indx<<" "<<hex<<data<<" "<<dec<<"  :";


    if (data & 0x80000000) { // Block Header
      if (((data & 0xf8000000) >>27) == 0x10) { // Block Header
	SLOTNUM = ((data& 0x7C00000)>>22);
	if (SLOTNUM<11){
	  SLOTNUM -=3;
	} else {
	  SLOTNUM -= 5;
	}
	EventsInBlock = (data & 0x000FF);
	if (DEBUG)
	  OUTF<<"Block Header"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x12) { // Event Header
	EVENT = data & 0x003FFFFF;
	if (DEBUG)
	  OUTF<<"Event Header"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x13) { // Trigger Time
	TriggerTime_1 = (data & 0x00FFFFFF);
	data = (unsigned int)LSWAP(outEvent->data[Indx+1]);
	//OUTF<<Indx<<" "<<hex<<data<<" "<<dec<<endl;
	TriggerTime_2 = (data & 0x00FFFFFF);
	if (DEBUG)
	  OUTF<<"Trigger Time"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x14) { // Window Raw Data header
	CHANNEL = ((data & 0x7F00000)>>20) - 1; // flash is couning channels from 1 to 72 need 0 to 71
	WSize =  (data & 0xFFF);
	
	if (DEBUGGER){
	  if (DATAReady!=0){ 
	    OUTF<<"EVENT "<<EventCounter<<"           DATAREADY: "<<DATAReady<<endl; 
	    dmaPFreeItem(outEvent);
	    return;
	  }
	  if (WSize!=10){ 
	    OUTF<<"EVENT "<<EventCounter<<"           WINDOWSIZE: "<<WSize<<endl;
	    if (!DEBUG){
	      dmaPFreeItem(outEvent);
	      return;
	    }
	  }
	}
	//cout<<"Window Size: "<<WSize<<endl;
	DATAReady = WSize/2;
	idx = 0;
	Ped[SLOTNUM][CHANNEL] = 0.;
	pedcnt = 0;
	if (DEBUG)
	  OUTF<<"Window Raw Data Header, WSize is "<<WSize<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1d){// End of event
	if (DEBUG)
	  OUTF<<"End of EVENT"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1f){
	if (DEBUG)
	  OUTF<<"Filler Word"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x11){
	if (DEBUG)
	  OUTF<<"Block Trailer"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x18){
	if (DEBUG)
	  OUTF<<"0x18 Unknown type"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x19){
	if (DEBUG)
	  OUTF<<"Streaming RAW DATA!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x16){
	if (DEBUG)
	  OUTF<<"Puls RAW DATA!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x15){
	if (DEBUG)
	  OUTF<<"Window SUM!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1e){
	if (DEBUG)
	  OUTF<<"DATA NOT VALID!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x17){
	if (DEBUG)
	  OUTF<<"PULSE INTEGRAL!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x16){
	if (DEBUG)
	  OUTF<<"Puls RAW DATA!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x15){
	if (DEBUG)
	  OUTF<<"Window SUM!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1a){
	if (DEBUG)
	  OUTF<<"UNKNOWN!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1b){
	if (DEBUG)
	  OUTF<<"UNDEFINED TYPE!! WHY???"<<endl;
      } else if (((data & 0xf8000000)>>27) == 0x1c){
	if (DEBUG)
	  OUTF<<"SCALER HEADER!! WHY???"<<endl;
      }
    } else if (DATAReady>0) { // Window Raw Data values
      if (DEBUG){
	OUTF<<"The actual DATA!"<<endl;
      }
      DATAReady--; 
      ADCSamples[SLOTNUM][CHANNEL][idx++] =  (data & 0x1FFF0000) >> 16;
      ADCSamples[SLOTNUM][CHANNEL][idx++] =  (data & 0x1FFF);
      adc1 = (float) ((data & 0x1FFF0000) >> 16);
      adc2 = (float) (data & 0x1FFF);
      //cout<<SLOTNUM<<" "<<CHANNEL<<" "<<idx<<" "<<adc1<<"  "<<adc2<<endl;
      if (pedcnt<9){
	Ped[SLOTNUM][CHANNEL] += (adc1+adc2); 
	pedcnt += 2;
	if (pedcnt>9){
	  Ped[SLOTNUM][CHANNEL] /= 10.;
	  PedSum[SLOTNUM][CHANNEL] += Ped[SLOTNUM][CHANNEL];
	  PedSum2[SLOTNUM][CHANNEL] += (Ped[SLOTNUM][CHANNEL]*Ped[SLOTNUM][CHANNEL]);
	  PedSumCntr[SLOTNUM][CHANNEL] += 1.;
	}
      } else {
	float v1 = adc1 -  Ped[SLOTNUM][CHANNEL];
	float v2 = adc2 -  Ped[SLOTNUM][CHANNEL];
	if ((v1>Thresholds[SLOTNUM][CHANNEL] || v2>Thresholds[SLOTNUM][CHANNEL])){
	  OT[SLOTNUM][CHANNEL] = 1;
	}
	
      }
    } else {
      if (DEBUG)
	OUTF<<"Other stuff"<<endl;
    }
    
  } // end of loop over all data
  
  dmaPFreeItem(outEvent);

  if (DEBUG){
    OUTF<<"Event "<<EventCounter<<"            WSIZE =  "<<WSize<<endl;
  }
  for (int j=0; j<NADCS;j++) {
    for (int i=0; i<72;i++) {
      
      if ((OT[j][i])||(RAWDATA)){
	OUTF<<EventCounter<<" "<<j<<" "<< i <<"  ";
	for (int k=0; k<WSize;k++){
	//for (int k=0; k<8;k++){
	  OUTF<< ADCSamples[j][i][k]<< " "; 
	}
	OUTF<<endl;
      }
    }

  }

  if (!(EventCounter%DOPEDS)){
    mkpedestals();
    unsigned int time = (clock()-START)/CLOCKS_PER_SEC;
    cout<<time<<" s   :"<<EVENT<<" "<<EventCounter<<endl;
    START = clock();
    timelaps += time;
  }
  
}
//
//
//
void mkpedestals(){

  PedestalCounter++;
    
  for (int n=0;n<NADCS;n++){
    int SLOT = n+3;
    if (SLOT>10){
      SLOT += 2;
    }
    for (int k=0;k<72;k++){
      //float mu = PedSum[n][k]/(float)EventCounter;
      //float r = PedSum[n][k]/((float)EventCounter-1.);
      //float sig = sqrt( PedSum2[n][k]/((float)EventCounter-1) - mu*r );
      float mu=0,r=0,sig=0;
      if (PedSumCntr[n][k]>1){
	mu  = PedSum[n][k] / PedSumCntr[n][k];
	r   = PedSum[n][k] / ( PedSumCntr[n][k] - 1. );
	sig = sqrt( PedSum2[n][k]/( PedSumCntr[n][k] - 1. ) - mu*r );
      }
      OUTFPed<<HOSTROC<<"  "<<PedestalCounter<<"    "<<SLOT<<" "<<k+1<<"   "<<mu<<"  "<<sig<<endl;
      PedSum[n][k] = 0.;
      PedSum2[n][k] = 0.;
      PedSumCntr[n][k] = 0.;
    }
  }
  
}