/***************************************************************************
                          event.cc  -  description
                             -------------------
    begin                : Tue Mar 7 2000
    copyright            : (C) 2000 by Liuht
    email                : liuht@particle.phys.ethz.ch
 **************************************************************************/

#include "event.hh"
#include "track.hh"
#include "TDirectory.h"
#include "STrack.h"
#include <assert.h>

ClassImp(Event);
TClonesArray *Event::fgTracks = 0;
TClonesArray *Event::fgSTracks= 0;

Event::Event(){
  if (!fgTracks) fgTracks = new TClonesArray("Track", 100);
  fTracks = fgTracks;
  if(!fgSTracks) fgSTracks = new TClonesArray("STrack",100);
  fSTracks = fgSTracks;
  fNstrack = 0;
  fNtrack = 0;RunID=0;EventID=0;
  CurrentSuperTrack=-1;
  st.SetOrigin(0);
  st.SetEnd(-1);
  st.SetTracks(fTracks); 
};

Event::Event(int RI,int EI):RunID(RI),EventID(EI){
  if (!fgTracks) fgTracks = new TClonesArray("Track", 100);
  fTracks = fgTracks;
  if(!fgSTracks) fgSTracks = new TClonesArray("STrack",10);
  fSTracks = fgSTracks;
  fNstrack = 0;
  fNtrack = 0;RunID=0;EventID=0;
  CurrentSuperTrack=0;
  st.SetOrigin(0);
  st.SetEnd(-1);
  st.SetTracks(fTracks); 
}

Event::~Event(){
fSTracks->Clear();
fTracks->Clear();
//if(fSTracks) delete fSTracks;
//if(fTracks) delete fTracks;

}

void
Event::AddTrack(int TI,int PI,int TT,double* pos,double* mom,int
parent,int PDG,int bounce,double charge,double mass,double TLength,
double TLife,const char* pname,const char* ppname, const char* kp,
const char* CV, const char* OV, double* OP, double* OM ){
  int ancientid= 0;
  if (TT >4)
    if ( rf.IsEmpty() && st.IsReenter()){
      rf.AddAncient(TI);
      ancientid = TI;
    }
    else  ancientid = rf.PushIn(TI,parent);
  assert(st.end == fNtrack -1);
  TClonesArray &tracks = *fTracks;
  new(tracks[fNtrack++]) Track(TI, PI, TT,pos,mom,parent,PDG,bounce,charge, 
      mass,TLength,TLife,pname,ppname,kp,CV,OV,OP,OM,ancientid);
  st.IncreaseEnd();
  if (TT >4){
  int type = st.CalType();
    if (type < 0) 
      RemoveSuperTrack();     
    else {
      TClonesArray &stracks = *fSTracks;
      new(stracks[fNstrack++]) STrack(st);
    };
    st.SetOrigin(fNtrack); 
    assert(st.GetNtracks() == 0);
  };  
 
};


void
Event::Clear(Option_t *option)
{
   fTracks->Clear(option);
   fNtrack = 0;
   fSTracks->Clear(option);
   fNstrack = 0;
   st.SetOrigin(0);
   st.SetEnd(-1);
   rf.Clear();

}

void
Event::Streamer(TBuffer &R__b)
{
   // Stream an object of class Event.

   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion();
      if (R__v) {
      	TObject::Streamer(R__b);
	  R__b >> RunID;
  	  R__b >> EventID;
    	  R__b >> fNtrack;
	  if(R__v > 5)	R__b >> fNstrack;
    	  fTracks->Clear();
	  fTracks->Streamer(R__b);
	  if(R__v > 4){
	    fSTracks->Clear();
	    fSTracks->Streamer(R__b);
	    SetTracksForSuperTracks();  
	  };
 
	              }
   } else {
      R__b.WriteVersion(Event::IsA());
      TObject::Streamer(R__b);
      R__b << RunID ;
      R__b << EventID;
      R__b << fNtrack;
      R__b << fNstrack;
      fTracks->Streamer(R__b);
      fSTracks->Streamer(R__b);
   }
}
int
Event::GetParent(int ParentTrackID){
  int Itrack;
  Itrack = -999;
  for (int i= 0; i < fNtrack; i++)
    if (ParentTrackID == ((Track*)fTracks->At(i))->GetTrackID())
      Itrack = i;
  return Itrack;
}

int 
Event::GetPreviousTrackID(){
return ((Track*)fTracks->At(fNtrack-1))->GetTrackID();
};

void
Event::FindSuperTracks(){
  fSTracks->Clear();
  fNstrack=0;
  TClonesArray &stracks = *fSTracks;
  int TrackID = ((Track*)fTracks->At(0))->GetTrackID();
  int oldTrackID = TrackID;
  int origin=0;
  int i;
  for (i = 0 ; i < fNtrack; i++){
    int TrackID = ((Track*)fTracks->At(i))->GetTrackID();
    if (TrackID != oldTrackID){
      oldTrackID= TrackID;
      new(stracks[fNstrack++]) STrack(origin,i-1);
      origin = i;
      };   
  };
  new(stracks[fNstrack++]) STrack(origin,i-1);
  SetTracksForSuperTracks();
  CalSuperTrackType();
};   


void
Event::Print(Option_t *){
  cout << '\t' << fNstrack << "\t super tracks in this event" << endl;
  cout <<"\t STrack Number" <<'\t' << "TrackType " << "Track numbers" << endl;
  for(int i = 0; i < fNstrack; i++)
  cout << '\t'<<i<<'\t' << GetSTrack(i)->GetType() << '\t' <<  GetSTrack(i)->GetNtracks()<< endl;
};

void
Event::Print(int type){
cout <<"\t STrack Number" <<'\t' << "TrackType " << "Track numbers" << endl;
  for(int i = 0; i < fNstrack; i++)
  if (GetSTrack(i)->GetType() == type)
   cout << '\t'<<i<<'\t' << GetSTrack(i)->GetType() << '\t' <<  GetSTrack(i)->GetNtracks()<< endl;
};
STrack *
Event::GetNext(){
  if(++CurrentSuperTrack >= fNstrack){
    cout <<" out of range " << endl;
    return 0;
    }
   else
     return  GetSTrack(CurrentSuperTrack);
};

STrack *
Event::GetNext(int type){
  while (STrack *pstrack = GetNext()){
    if (pstrack->GetType() == type)
      return pstrack;
  };
  return 0;
}; 
        
void 
Event::RemoveSuperTrack(){
  for (int i = st.end; i >= st.origin; i--){
    fNtrack--;
    fTracks->RemoveAt(fNtrack);
  };
  st.SetEnd(fNtrack-1);
};


void
Event::Shrink(Event *pevent,int type) {
  pevent->Clear();
  STrack *pstrack = GetSTrack(0);
  pevent->AddStrack(pstrack);
  CurrentSuperTrack = 0;
  while (pstrack = GetNext(type))
    pevent->AddStrack(pstrack);
  pevent->SetTracksForSuperTracks();
};

void
Event::Shrink(int type){
  static  TObjArray tmptracks;
  CurrentSuperTrack = 0;
  int k=0;
  STrack* pstrack= GetAbsSTrack(0);
  tmptracks.Clear();
  for(int j = pstrack->origin; j <= pstrack->end; j++)
    { tmptracks.Add(fTracks->At(j));
      k++;
     }; 
  for (int i = 1; i < fNstrack; i++){
    pstrack= GetAbsSTrack(i);
    if (pstrack->GetType() == type)
      for(int j = pstrack->origin; j <= pstrack->end; j++)
        { tmptracks.Add(fTracks->At(j)); 
	  k++;
	};  
     
  };
  Clear();
  for(fNtrack=0; fNtrack < k; fNtrack++)
   fTracks->Add(tmptracks[fNtrack]);
  FindSuperTracks();
};

void 
Event::AddStrack(STrack* pstrack) {
  int origin = fNtrack;
  int length = pstrack->GetNtracks();
  TClonesArray &tracks = *fTracks;
  for (int i = 0; i < length; i++)
    new(tracks[fNtrack++]) Track(*(pstrack->GetTrack(i)));
  TClonesArray &stracks = *fSTracks;
  new(stracks[fNstrack++]) STrack(origin,origin+length-1,pstrack->GetType());
};

STrack * 
Event::GetSTrack(int i) const{
  if(i >= fNstrack){
    cout <<" out of bounds" << endl;
    return 0;
  };
  int k = 0;
  for (int j = 0 ; j < fSTracks->GetLast()+1; j++){
    STrack *pstrack = (STrack*) fSTracks->At(j);
    if (pstrack && i==k++)  return pstrack;
  };  
};