//
//  $Id: BrLocalTrackModule.cxx,v 1.4 1998/06/21 14:34:51 hagel Exp $
//
//  $Log: BrLocalTrackModule.cxx,v $
//  Revision 1.4  1998/06/21 14:34:51  hagel
//  Correct problem in BrDigitizeDC; clean up tests
//
//  Revision 1.3  1998/04/06 21:12:18  videbaek
//  Clean up and additions for Win95
//
//
#include "BrLocalTrackModule.h"
#include "iostream.h"
#include "BrDataTable.h"
#include "BrEventNode.h"
#include "TSonataMath.h"

ClassImp(BrLocalTrackModule)

//////////////////////////////////////////////////////////////////////////////
//																			//
// BrLocalTrackModule is a class for general tracking.  Both TPC and DC		  //
// tracking objects inherit from it and use its methods.					          //
//																			//
//////////////////////////////////////////////////////////////////////////////

  BrLocalTrackModule::BrLocalTrackModule()
 :BrModule()
{
// Constructor.
//
CreateClonesArrays(); 
}

  BrLocalTrackModule::BrLocalTrackModule(Text_t *Name,Char_t *Title)
 :BrModule(Name,Title)
{
// Default constructor for user.
// The name and title should be ste properly.
//
CreateClonesArrays();
}

 void BrLocalTrackModule::CreateClonesArrays()
{
CombinedHits  = new BrClonesArray("BrCombinedHit",1000);
LocalTracks   = new BrClonesArray("BrLocalTrack",1000);
TrackHits     = new BrClonesArray("BrTrackHit",1000);
VirtualTracks = new BrClonesArray("BrVirtualTrack",1000);
}

 BrLocalTrackModule::~BrLocalTrackModule(){
//
// Destructor
// detele the clones array always created in constructor
//
delete CombinedHits;
delete LocalTracks;
delete TrackHits;
delete VirtualTracks;
}

 void BrLocalTrackModule::GetHitCMBMod(Int_t imod,BrDataTable *HitCMBMod)
{
Int_t i;
Int_t NumHitCMB;
BrCombinedHit *hitcmb_p;
//#define SORT_HITCMB

NumHitCMB = CombinedHits->GetEntries();
for(i=0;i<NumHitCMB;i++) {
   hitcmb_p = (BrCombinedHit*)CombinedHits->At(i);
   if(( hitcmb_p->GetImod()  == imod  ) || ( imod  == IANY ) ) {
      HitCMBMod->Add(hitcmb_p);
	  }
   }

#ifdef SORT_HITCMB
HitCMBMod->Sort();
#endif
}

 void BrLocalTrackModule::InsertTrahit(BrCombinedHit *hitcmbb,BrLocalTrack* loctraa)
{
BrTrackHit* trahit_p;

//This should already be debugged

//trahit[NumTraHit] = new traHIT();
//trahit_p = trahit[NumTraHit];
//NumTraHit++;
//if(NumTraHit > maxtrahit) cout<<"NumTraHit too large"<<endl;
BrClonesArray &trahit = *TrackHits;
Int_t ntrahit = TrackHits->GetEntries();
trahit_p = new(trahit[ntrahit]) BrTrackHit();
//trahit[numtrahit]->gvolu = &gvolu;//need to get this back!!!!
trahit_p->SetImod(hitcmbb->GetImod());
trahit_p->SetTrID(loctraa);
//do we really need these two or does it just arrive because
//of differences from FORTRAN version?  Do it for the moment.
trahit_p->SetLoctra(loctraa);
trahit_p->SetHitcmb(hitcmbb);

//numtrahit = loctraa->numtrahit;
//if(numtrahit > maxloctrahit) printf("numtrahit in loctra too large");
//loctraa->trahit[numtrahit] = trahit_p;
//loctraa->numtrahit++;
loctraa->AddTrackHit(trahit_p);
}

 void BrLocalTrackModule::RemoveTrack(BrLocalTrack* loctraa)
{

//This routine should be more or less debugged although
//the results don't match exactly SONATA after the first time
//through.  I think for the moment that is because of the
//different way it is done here and in using ADAMO.  This should
//be monitored

//For future reference, this can be done in a much easier way
//using the numtrahit and trahit entries in loctra.  That gives
//us the information directly without having to do a search.
Int_t i,j;
//Int_t MOD(Int_t dividend,Int_t divisor);
Int_t NumTraHitLoctra = 0;
BrTrackHit *trahit_p;
BrCombinedHit *hitcmb_p;
Int_t NumTraHit;
Int_t NumHitCMB;
NumHitCMB = CombinedHits->GetEntries();
NumTraHit = TrackHits->GetEntries();
for( i=0;i<NumTraHit;i++) {
   trahit_p = (BrTrackHit*)TrackHits->At(i);
   if(trahit_p->GetTrID() == loctraa) {
      NumTraHitLoctra++;
//    First, find if any hitcmb corresponds to this and reset stat
      for(j=0;j<NumHitCMB;j++) {
	     hitcmb_p = (BrCombinedHit*)CombinedHits->At(j);
	     if( trahit_p->GetHitcmb() == hitcmb_p ) {
		    hitcmb_p->SetStat(TSonataMath::MOD(hitcmb_p->GetStat(),16) + (hitcmb_p->GetStat()/16-1)*16);
		    }
	     }
//    Now Delete this track.
//      delete trahit[i];
//    first we need to remove it from the local track
      loctraa->RemoveTrackHit(trahit_p);
      TrackHits->RemoveAt(i);
//	  delete trahit_p;
//	  i--;//?????
      }
   }
TrackHits->Compress();
loctraa->SetStat(999);
}

 void BrLocalTrackModule::DeleteBadTrack()
{
Int_t i;
Int_t NumLoctra;
BrLocalTrack *loctra_p;

NumLoctra = LocalTracks->GetEntries();
for(i=0;i<NumLoctra;i++) {
   loctra_p = (BrLocalTrack*)LocalTracks->At(i);
   if( loctra_p->GetStat() == 999 ) {
      LocalTracks->RemoveAt(i);
//	  delete loctra_p;
//	  i--;
      }
   }
LocalTracks->Compress();
}

 void BrLocalTrackModule::FillVTracks(Int_t ncutoff)
{
Int_t i,j,i1,i2;
Int_t nsame;

Int_t NumLoctra;
BrLocalTrack *loctra_p1;
BrLocalTrack *loctra_p2;
BrVirtualTrack *vtrack_p;

Int_t NumTrHits1Sel;
BrDataTable TrHits1Sel;
Int_t NumTrHits2Sel;
BrDataTable TrHits2Sel;

BrCombinedHit *hitcmb_p1;
BrCombinedHit *hitcmb_p2;

//printf("Entering FillVTracksn");
NumLoctra = LocalTracks->GetEntries();
for(i=0;i<NumLoctra;i++) {
   loctra_p1 = (BrLocalTrack*)LocalTracks->At(i);
   if( loctra_p1->GetVtrack() == INULL ) {
//    vtrack[NumVTrack] = new vTRACK();
//    numvtrack = NumVTrack;
//    NumVTrack++;
//    if(NumVTrack > maxvtrack) cout<<"NumVTrack too large"<<endl;
      BrClonesArray &vtracks = *VirtualTracks;
      Int_t nvtracks = VirtualTracks->GetEntries();
      vtrack_p = new(vtracks[nvtracks]) BrVirtualTrack();

//    vtrack[numvtrack]->gvolu = &gvolu;

      vtrack_p->AddLoctra(loctra_p1);
//    vtrack[numvtrack]->loctra[0] = loctra[i];
//    vtrack[numvtrack]->numloctra = 1;

//    loctra[i]->vtrack = vtrack[numvtrack];
      loctra_p1->SetVtrack(vtrack_p);

      TrHits1Sel.Clear();
      FillHitCMBSelector(loctra_p1,&TrHits1Sel);
      for(j=i+1;j<NumLoctra;j++) {
	 loctra_p2 = (BrLocalTrack*)LocalTracks->At(j);
         if( loctra_p2->GetVtrack() == INULL ) {
	    TrHits2Sel.Clear();
	    FillHitCMBSelector(loctra_p2,&TrHits2Sel);

//          Compare hits for ghost
	    nsame = 0;
	    NumTrHits1Sel = TrHits1Sel.GetEntries();
//	    NumTrHits1Sel = loctra_p1->GetTrackEntries();
            for(i1=0;i1<NumTrHits1Sel;i1++) {
	       hitcmb_p1 = (BrCombinedHit*)TrHits1Sel.At(i1);
//             hitcmb_p1 = loctra_p1->GetTrackHitAt(i1)->GetHitcmb();
	       NumTrHits2Sel = TrHits2Sel.GetEntries();
//		   NumTrHits2Sel = loctra_p2->GetTrackEntries();
	           for(i2=0;i2<NumTrHits2Sel;i2++) {
		      hitcmb_p2 = (BrCombinedHit*)TrHits2Sel.At(i2);
//                    hitcmb_p2 = loctra_p2->GetTrackHitAt(i2)->GetHitcmb();
	              if(hitcmb_p1 == hitcmb_p2) {
		         nsame++;
		         }
		      }
	           }
//	    decide on sameness of ghost tracks
//          Beware that this loop works.  Ncutoff should be related
//          to the number of planes etc.
            if(nsame>=ncutoff) {
	           loctra_p2->SetVtrack(vtrack_p);
//	           int numvtrackloctra = vtrack[numvtrack]->numloctra;
//             if(numvtrackloctra>maxvtrackloctra) printf("numvtrackloctra too largen");
//	           vtrack[numvtrack]->loctra[numvtrackloctra] = loctra[j];
//	           vtrack[numvtrack]->numloctra++;
               vtrack_p->AddLoctra(loctra_p2);
	           }
	        if((nsame == NumTrHits1Sel) &&
	           (nsame == NumTrHits2Sel)) {
	           cout<<"Problem; two tracks are the same"<<endl;
	           }
	        }
         }
      }
   }
TrHits1Sel.Clear();
TrHits2Sel.Clear();
}

 void BrLocalTrackModule::FillLocalTracks(BrEventNode* OutputTable)
{
Int_t ivt,ic,numvtrackloctra;
Float_t chimin;
Int_t PreferredTrack;
Int_t NumVTrack;

BrLocalTrack* loctra_p;
BrVirtualTrack* vtrack_p;
BrDetectorTrack* titr_p;

//Prepare the output table
Char_t TableName[32];
sprintf(TableName,"%s Detector Tracksx0",GetName());
BrDataTable *DetectorTracks = new BrDataTable(TableName);
OutputTable->AddObject(DetectorTracks);

NumVTrack = VirtualTracks->GetEntries();
for(ivt=0;ivt<NumVTrack;ivt++) {
   vtrack_p = (BrVirtualTrack*) VirtualTracks->At(ivt);

// Look in the list of loctra connected to the vtrack and pick
// the "best"??

   PreferredTrack = 0;
   chimin = (float)1000000.;
   numvtrackloctra = vtrack_p->GetLoctraEntries();
   for(ic=0;ic<numvtrackloctra;ic++) {
      loctra_p = vtrack_p->GetLoctraAt(ic);
      if( loctra_p->GetChisq() < chimin ) {
         PreferredTrack = ic;
	 chimin = loctra_p->GetChisq();
	 }
      }

   titr_p = new BrDetectorTrack();
   DetectorTracks->Add(titr_p);

   loctra_p = vtrack_p->GetLoctraAt(PreferredTrack);
   titr_p->SetPos (loctra_p->GetPos());
   titr_p->SetAlph(loctra_p->GetVec());
   titr_p->SetLoctra(loctra_p);
   titr_p->SetVtrack(vtrack_p);

   }
Int_t numtracks = DetectorTracks->GetEntries();
if(numtracks > 0) {
   cout<<"Number of Tracks for "<<GetName()<<" is "<<numtracks<<endl;
   for(Int_t i=0;i<numtracks;i++) {
      titr_p = (BrDetectorTrack*)DetectorTracks->At(i);
      cout<<titr_p;
      }
    }
}

 void BrLocalTrackModule::FillHitCMBSelector( BrLocalTrack* loctra,BrDataTable *HitCMBSel)
{
int ic;
//Find the hitcmb which are related through the loctra part.
//i.e. the non-mainview planes.
Int_t NumTraHit;
BrTrackHit *trahit_p;

HitCMBSel->Clear();

NumTraHit = TrackHits->GetEntries();
for(ic=0;ic<NumTraHit;ic++) {
   trahit_p = (BrTrackHit*)TrackHits->At(ic);
   if(loctra == trahit_p->GetLoctra() ) {
      if( trahit_p->GetHitcmb() ) {
	     HitCMBSel->Add(trahit_p->GetHitcmb());
//	     HitCMBSel[numhitcmbsel] = trahit[ic]->hitcmb;
//		 numhitcmbsel++;
	     }
      }
   }

if(loctra->GetTr1() == 0) return;

for(ic=0;ic<NumTraHit;ic++) {
   trahit_p = (BrTrackHit*)TrackHits->At(ic);
   if(loctra->GetTr1() == trahit_p->GetTra2d() ) {
      if( trahit_p->GetHitcmb() ) {
	     HitCMBSel->Add(trahit_p->GetHitcmb());
	     }
      }
   }

for(ic=0;ic<NumTraHit;ic++) {
   trahit_p = (BrTrackHit*)TrackHits->At(ic);
   if(loctra->GetTr2() == trahit_p->GetTra2d() ) {
      if( trahit_p->GetHitcmb() ) {
	     HitCMBSel->Add(trahit_p->GetHitcmb());
	     }
      }
   }


}