// -------------------------------------------------------------------------
// -----                        AsyUnpack source file                  -----
// -----          Created 12/04/12  by P. Russotto                    -----
// -------------------------------------------------------------------------

#include "MBUnpack.h"
#include "FairLogger.h"
#include "TClonesArray.h"
#include "TSystem.h"
#define pi 3.141592654
#include <TMath.h>
#define ndetR 51
using std::cout;
using std::endl;
Bool_t Debug = false;
  double www[ndetR]={
   0.000000,//0
   0.774897,//1
   0.911355,//2
   0.942403,//3
   0.904101,//4
   1.000000,//5
   0.936506,//6
   0.844652,//7
   0.524097,//8
   1.000000,//9
   0.604620,//10
   0.563093,//11
   0.572836,//12
   0.649637,//13
   0.609467,//14
   1.000000,//1
   1.002660,//2
   0.995709,//3
   0.270008,//4
   1.000000,//5
   0.826901,//6
   0.760568,//7
   0.607999,//8
   0.547973,//9
   0.683727,//10
   0.673831,//11
   0.605235,//12
   0.597465,//13
   0.742115,//14
   0.906744,//1
   0.862440,//2
   0.812637,//3
   1.097110,//4
   1.000000,//5
   0.774831,//6
   0.709158,//7
   0.828360,//8
   0.720798,//9
   0.805353,//10
   0.718919,//11
   1.027610,//12
   1.007060,//1
   0.880078,//2
   1.179210,//3
   1.000000,//4
   0.843540,//5
   0.969063,//6
   0.949493,//7
   1.109400,//8
   0.990681,//9
   0.331605,//10
  };

MBUnpack::MBUnpack()
  :FairTask()
{
                   //init calibration
}


// -------------------------------------------------------------------------
MBUnpack::MBUnpack(const char* name, Int_t iVerbose)
  : FairTask(name, iVerbose),
    fMBall_evt(0),
    fRootMBallEvent(0),
    fRootMBallEventCopy(0),
    fRootMBallGlobal(0),
    fRootMBallGlobalCopy(0),
    fMBSTSCopy(0),
    fMBSTS(0),
    ffBufferClone(0)
{
}
// -------------------------------------------------------------------------
MBUnpack::~MBUnpack() 
{ 
}
// -------------------------------------------------------------------------
InitStatus MBUnpack::Init()
{
   fLogger->Info(MESSAGE_ORIGIN," MBallUnpack::Init()------------------Start "); 

  string dir=gSystem->Getenv("VMCWORKDIR");
//  string dir = getenv("VMCWORKDIR");
  string caldir = dir + "/macros/";
  string MBmapping = caldir + "microball_mappingwTDC2.txt";
  string MBthresh = caldir + "adc_thresh.dat";
//  getchar();

  fMBall_evt= new TMBALLEvent();
  fMBall_evt->LoadMapping(MBmapping.c_str());
  cout << "read " << MBmapping << endl;
  fMBall_evt->LoadThresholds(MBthresh.c_str());
  cout << "read " << MBthresh << endl;

  
  fRootMBallEvent= new  TRootMBallEvent();
  fRootMBallGlobal= new  TRootMBallGlobal();
  fMBSTS = new TRootTS();
  
  FairRootManager* ioman = FairRootManager::Instance();
  if ( ! ioman ) Fatal("Init", "No FairRootManager");


  ioman->Register("MBALLEVENT", "MBALL EVENT TREE", fRootMBallEvent, kFALSE);
  ioman->Register("MBALLGLOBAL", "MBALL GLOBAL TREE", fRootMBallGlobal, kFALSE);
  ioman->Register("MBSTS", "MBS TIME STAMP", fMBSTS, kFALSE);
  
  fMBSTSCopy = new TClonesArray("TRootTS");
  fRootMBallEventCopy = new TClonesArray("TRootMBallEvent");
  fRootMBallEventCopy=(TClonesArray*)fRootMBallEvent;
  fRootMBallGlobalCopy = new TClonesArray("TRootMBallGlobal");
  fRootMBallGlobalCopy=(TClonesArray*)fRootMBallGlobal;
  fMBSTSCopy=(TClonesArray*)fMBSTS;
  ioman->Register("MBALLEVENTCLONE", "MBALL EVENT TREE CLONE", fRootMBallEventCopy, kFALSE);
  ioman->Register("MBALLGLOBALCLONE", "MBALL GLOBAL TREE CLONE", fRootMBallGlobalCopy, kFALSE);
  ioman->Register("MBSTSCLONE", "MBS TIME STAMP CLONE", fMBSTSCopy, kFALSE);

  ffBufferClone =(TClonesArray*) ioman->GetObject("EVTBUFFERCLONE");
  ffBuffer = (TEvtBuffer*)ffBufferClone;
  
  fLogger->Info(MESSAGE_ORIGIN," MBallUnpack::Init()------------------End "); 
  cout << " ...return to continue..."<< endl;
  getchar();
}
// -------------------------------------------------------------------------
void MBUnpack::SetParTask()
{
}
// -------------------------------------------------------------------------
void MBUnpack::Finish()
{
//    if(fIsLastEvent) 
//    fLogger->Info(MESSAGE_ORIGIN," Finish all events in file");
}
// -------------------------------------------------------------------------
void MBUnpack::Reset()
{
}
// -------------------------------------------------------------------------
void MBUnpack::Exec(Option_t* opt)
{
/*  cout <<"MBallUnpack::Exec*****************BEGIN***************"<<endl;   
  fLogger->Info(MESSAGE_ORIGIN," MBUnpack::Exec(Option_t* opt) ");*/
  int Trig_Patt;
  int bit_Trig_Patt[16];
//  Trig_Patt=*SubEventDataPtr;
  Trig_Patt=ffBuffer->TPattBuffer[0];
  fMBSTS->TPatt=Trig_Patt;
/*  for (int k=0;k<16;k++){
   bit_Trig_Patt[k]=0;
  }
  if(Trig_Patt & 0x0001) bit_Trig_Patt[0] =1;
  if(Trig_Patt & 0x0002) bit_Trig_Patt[1] =1;
  if(Trig_Patt & 0x0004) bit_Trig_Patt[2] =1;
  if(Trig_Patt & 0x0008) bit_Trig_Patt[3] =1;
  if(Trig_Patt & 0x0010) bit_Trig_Patt[4] =1;
  if(Trig_Patt & 0x0020) bit_Trig_Patt[5] =1;
  if(Trig_Patt & 0x0040) bit_Trig_Patt[6] =1;
  if(Trig_Patt & 0x0080) bit_Trig_Patt[7] =1;
  if(Trig_Patt & 0x0100) bit_Trig_Patt[8] =1;
  if(Trig_Patt & 0x0200) bit_Trig_Patt[9] =1;
  if(Trig_Patt & 0x0400) bit_Trig_Patt[10]=1;
//  cout << "Trig_Patt= " << Trig_Patt << endl;
  fMBSTS->TPatt=Trig_Patt;
//  for (int k=0;k<16;k++){
//   cout << "k= "<<k<<" "<<bit_Trig_Patt[k]<<endl;
//  }*/
  
  int MBSTSs, MBSTSm,MBSTSh;
/*  cout << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"<<endl;             
  cout << "Found a valid MBS subevent OKKKKKKKKKKKKKKKKKKKKKKKKK"<< endl;
  cout << "Found a valid MBS subevent OKKKKKKKKKKKKKKKKKKKKKKKKK"<< (ffBuffer->MBSBuffer[0] & 0x0000ffff) <<endl;
  cout << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"<<endl;*/
   if( (ffBuffer->MBSBuffer[0] & 0x0000ffff) !=512){
    cout << "[MBUnpack::Exec] something wrong..first word of MBS buffer is "<< (ffBuffer->MBSBuffer[0] & 0x0000ffff) << endl;
    cout << "[MBUnpack::Exec] instead of 512 " << endl;
   }
   MBSTSs=(ffBuffer->MBSBuffer[1] & 0x0000ffff);
   MBSTSm=(ffBuffer->MBSBuffer[2] & 0x0000ffff);
   MBSTSh=(ffBuffer->MBSBuffer[3] & 0x0000ffff);
   fMBSTS->TSS=MBSTSs;
   fMBSTS->TSM=MBSTSm;
   fMBSTS->TSH=MBSTSh;
/*   cout << "MBS TIMESTAMPS"<<endl;
   cout << MBSTSs<< " " << MBSTSm << " " << MBSTSh << endl;
   cout << fMBSTS->TSS << " " << fMBSTS->TSM << " " << fMBSTS->TSH << endl;*/
   //_________________________________________________________________________________________
   //_____________________________MICROBALL subevent________________________________________________
   fMBall_evt->uBallModule.clear();                                                            
   fMBall_evt->uBallChannel.clear();                                             
   fMBall_evt->uBallData.clear();  

   if(Debug)  cout<<"MICROBALL event"<<endl;
   int unum = 0;
   if(Debug) cout<<"================ProcessCurrentEventMBS()=============="<<endl;
   fMBall_evt->ProcessCurrentEventMBS(ffBuffer->MBallBuffer,ffBuffer->MBall_nrw);
   if(Debug){
    cout << "MBall BUF= "<< (ffBuffer->MBallBuffer[0]  & 0x0000ffff)<<endl;
    cout << "MBall BUF= "<< (ffBuffer->MBallBuffer[1]  & 0x0000ffff)<<endl;
    cout << "MBall BUF= "<< (ffBuffer->MBallBuffer[2]  & 0x0000ffff)<<endl;
    cout << "MBall BUF= "<< (ffBuffer->MBallBuffer[3]  & 0x0000ffff)<<endl;
    cout << "MBall BUF= "<< (ffBuffer->MBall_nrw)<<endl;
   }
   if(Debug) cout<<"================Done in ProcessCurrentEventMBS()======"<<endl;
   if(Debug) cout <<"MBALL multi="<<fMBall_evt->GetMBALLMultiplicity()<<endl; //Multiplicity of channels above ADC threshold (Paola)
   //Paola--------this tells us if the halo detector has been fired-------------
   if(Debug) cout<<"Has the halo been fired? "<<fMBall_evt->IsHaloFired()<<endl;
   //--------------done with halo detector
   int MperR[4];
   for(int h=0;h<4;h++)
    MperR[h]=0;
	for(int uballi=0; uballi < fMBall_evt->GetMBALLMultiplicity(); uballi++) {
	  fRootMBallEvent->uBallnRing = 4;
	  
	  int ADCmodule = fMBall_evt->uBallModule[uballi];
	  int ADCchannel = fMBall_evt->uBallChannel[uballi];
	  
	  fRootMBallEvent->uBallModuleNum[unum]  = ADCmodule;
	  fRootMBallEvent->uBallChannelNum[unum] = ADCchannel;
	  fRootMBallEvent->uBallDataRaw[unum]    = fMBall_evt->uBallData[uballi];
	  
	  fRootMBallEvent->uBallRingNum[unum]    = fMBall_evt->GetDetectorRing(ADCmodule,ADCchannel);
	  fRootMBallEvent->uBallDetNum[unum]     = fMBall_evt->GetDetectorNumber(ADCmodule,ADCchannel);


         int  ring =  fMBall_evt->GetDetectorRing(ADCmodule,ADCchannel);
	 int det = fMBall_evt->GetDetectorNumber(ADCmodule,ADCchannel);
	  
	  fRootMBallEvent->uBallTheta[unum] = fMBall_evt-> GetTheta(ring, det);
//	  fRootMBallEvent->uBallPhi[unum] = fMBall_evt-> GetPhi(ring, det);
	  double phi=fMBall_evt-> GetPhi(ring, det)+90.;
	  if(phi>180)phi=phi-360;
	  if(phi>180)phi=phi-360;
	  fRootMBallEvent->uBallPhi[unum] = phi;
	  
	  MperR[ring-5]++;
	  

	  unum++; //Recalculated multiplicity, it has to be = to GetMBALLMultiplicity()
	}
	
	if(unum != fMBall_evt->GetMBALLMultiplicity())
	  cout<<"unum : "<<unum<<" "<< fMBall_evt->GetMBALLMultiplicity()<<" THEY ARE DIFFERENT!!"<<endl;
	
	//Saving multiplicities.....
	fRootMBallEvent->uBallmulti = unum;   //multiplicity above ADC pedestals
	for(int i=0;i<4;i++)
	  {
	    if(fMBall_evt->GetMBALLRingMultiplicity(i+5) != MperR[i]) cout<<"multiplicities per ring are different"<<endl;

	    fRootMBallEvent->uBallmultiR[i] = fMBall_evt->GetMBALLRingMultiplicity(i+5); //multiplicity above ADC pedest per ring
	  }

	//-----------------------Multiplicities saved-----------------
	
	//-----we save if the halo det has been fired or not ---Paola 28Oct2011
	fRootMBallEvent->HaloDetFired = fMBall_evt->IsHaloFired();
	
	
	
	//for (int i = 0; i < fMBall_evt->GetMBALLMultiplicity() ; i++) {
	//cout << "EVENT OUT TO ROOT FILE =====      " << evt->uBallModuleNum[i] << endl;
	//cout << "EVENT OUT TO ROOT FILE =====      " << evt->uBallChannelNum[i] << endl;
	//cout << "EVENT OUT TO ROOT FILE =====      " << evt->uBallDataRaw[i] << endl;
	//}
	
/*	fMBall_evt->uBallModule.clear();                                                            
	fMBall_evt->uBallChannel.clear();                                             
	fMBall_evt->uBallData.clear(); */ 
/*  cout <<"MBallUnpack::Exec*****************END***************"<<endl;   
  cout <<" "<<endl; 
   getchar();*/

 bool pprint=false;
 double QMBx=0,QMBy=0,QMB5x=0,QMB5y=0,QMB6x=0,QMB6y=0,QMB7x=0,QMB7y=0,QMB8x=0,QMB8y=0;
 double PhiMB=-1000,Phi5MB=-1000,Phi6MB=-1000,Phi7MB=-1000,Phi8MB=-1000;
 int used=0, used5=0,used6=0,used7=0,used8=0;
 double ww;
 if(pprint)cout << QMBx<<QMBy<<QMB5x<<QMB5y<<QMB6x<<QMB6y<<QMB7x<<QMB7y<<QMB8x<<QMB8y<<endl;
//MicroBall v9 29082012->

 fRootMBallGlobal->multi=fRootMBallEvent->uBallmulti;
 if(pprint)cout << fRootMBallGlobal->multi<<endl;


 int Roff;
 for(int jj=0;jj<fRootMBallEvent->uBallmulti;jj++){
  if(fRootMBallEvent->uBallRingNum[jj]==5){Roff=0;};
  if(fRootMBallEvent->uBallRingNum[jj]==6){Roff=14;};
  if(fRootMBallEvent->uBallRingNum[jj]==7){Roff=28;};
  if(fRootMBallEvent->uBallRingNum[jj]==8){Roff=40;};
  int detId  = fRootMBallEvent->uBallDetNum[jj];
  int detIdU = detId+Roff;
//  ww=1/(TMath::Power(www[detId],1.));
  ww=1/(TMath::Power(www[detIdU],1.));
  
  if(fRootMBallEvent->uBallRingNum[jj]==5){
   QMB5x=QMB5x+ww*cos((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   QMB5y=QMB5y+ww*sin((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   used5++;
  }
  if(fRootMBallEvent->uBallRingNum[jj]==6){
   QMB6x=QMB6x+ww*cos((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   QMB6y=QMB6y+ww*sin((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   used6++;
  }
  if(fRootMBallEvent->uBallRingNum[jj]==7){
   QMB7x=QMB7x+ww*cos((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   QMB7y=QMB7y+ww*sin((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   used7++;
  }
  if(fRootMBallEvent->uBallRingNum[jj]==8){
   QMB8x=QMB8x+ww*cos((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   QMB8y=QMB8y+ww*sin((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   used8++;
  }
  if(fRootMBallEvent->uBallRingNum[jj]>4 ){
   QMBx=QMBx+ww*cos((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   QMBy=QMBy+ww*sin((fRootMBallEvent->uBallPhi[jj])*pi/180.);
   used++;
  }
  if(pprint)cout << jj <<"   "<<fRootMBallEvent->uBallRingNum[jj]<<" "<<fRootMBallEvent->uBallDetNum[jj]<<" "<<fRootMBallEvent->uBallPhi[jj]<<" "<<ww<<endl;
 }
 //cout<< " " << endl<<endl<<endl;
 if(used >=2 && used<=46  && (QMBx  || QMBy ))PhiMB=(atan2(QMBy,QMBx)*180/pi);
 if(used5>=2 && used5<=13 && (QMB5x || QMB5y))Phi5MB=(atan2(QMB5y,QMB5x)*180/pi);
 if(used6>=2 && used6<=13 && (QMB6x || QMB6y))Phi6MB=(atan2(QMB6y,QMB6x)*180/pi);
 if(used7>=2 && used7<=11 && (QMB7x || QMB7y))Phi7MB=(atan2(QMB7y,QMB7x)*180/pi);
 if(used8>=2 && used8<=9 && (QMB8x || QMB8y))Phi8MB=(atan2(QMB8y,QMB8x)*180/pi);
 if(pprint)cout << QMBx<<"  "<<QMBy<<"  "<<QMB5x<<"  "<<QMB5y<<"  "<<QMB6x<<"  "<<QMB6y<<"  "<<QMB7x<<"  "<<QMB7y<<"  "<<QMB8x<<"  "<<QMB8y<<endl;
 if(pprint)cout << PhiMB<<"  "<<Phi5MB<<"  "<<Phi6MB<<"  "<<Phi7MB<<"  "<<Phi8MB<<"  "<<endl;

 fRootMBallGlobal->Qx=QMBx;
 fRootMBallGlobal->Qy=QMBy;
 fRootMBallGlobal->phirp=PhiMB;
//MicroBall v9 29082012-<
 if(pprint){
  cout << used5 <<" "<<used6<<" "<<used7<<" "<<used8<<endl;
  if(used5>13)getchar();
  if(used6>13)getchar();
  if(used7>11)getchar();
  if(used8>9)getchar();
  cout<< " " << endl<<endl<<endl;
 }

}
// -------------------------------------------------------------------------
ClassImp(MBUnpack)