NcJet.cxx

Go to the documentation of this file.

 
#include "NcJet.h"
#include "Riostream.h"
 
ClassImp(NcJet); // Class implementation to enable ROOT I/O
 
NcJet::NcJet() : TNamed(),Nc4Vector()
{
 
 Init();
 Reset();
 SetNtinit();
}

void NcJet::Init()
{
 
 fTracks=0;
 fNtinit=0;
 fTrackCopy=0;
 fRef=0;
 fSelected=0;
 fEscale=1;
}

NcJet::NcJet(Int_t n) : TNamed(),Nc4Vector()
{
 
 Init();
 Reset();
 if (n > 0)
 {
  SetNtinit(n);
 }
 else
 {
  cout << endl;
  cout << " *NcJet* Initial max. number of tracks entered : " << n << endl;
  cout << " This is invalid. Default initial maximum will be used." << endl;
  cout << endl;
  SetNtinit();
 }
}

NcJet::~NcJet()
{
 
 if (fTracks)
 {
  delete fTracks;
  fTracks=0;
 }
 if (fRef)
 {
  delete fRef;
  fRef=0;
 }
 if (fSelected)
 {
  delete fSelected;
  fSelected=0;
 }
}

void NcJet::SetOwner(Bool_t own)
{
 
 Int_t mode=1;
 if (!own) mode=0;
 if (fTracks) fTracks->SetOwner(own);
 fTrackCopy=mode;
}

NcJet::NcJet(const NcJet& j) : TNamed(j),Nc4Vector(j)
{
 
 fNtinit=j.fNtinit;
 fNtmax=j.fNtmax;
 fQ=j.fQ;
 fEscale=j.fEscale;
 fNtrk=j.fNtrk;
 fTrackCopy=j.fTrackCopy;
 fUserId=j.fUserId;
 if (j.fRef) fRef=new NcPositionObj(*(j.fRef));
 
 fSelected=0;
 
 fTracks=0;
 if (fNtrk)
 {
  fTracks=new TObjArray(fNtmax);
  if (fTrackCopy) fTracks->SetOwner();
 }
 
 for (Int_t i=1; i<=fNtrk; i++)
 {
  NcTrack* tx=j.GetTrack(i);
  if (fTrackCopy)
  {
   fTracks->Add(tx->Clone());
  }
  else
  {
   fTracks->Add(tx);
  }
 } 
}

void NcJet::SetNtinit(Int_t n)
{
 
 fNtinit=n;
 fNtmax=n;
 
 if (fTracks)
 {
  delete fTracks;
  fTracks=0;
 }
 if (fRef)
 {
  delete fRef;
  fRef=0;
 }
}

void NcJet::Reset()
{
 
 fNtrk=0;
 fQ=0;
 fUserId=0;
 SetZero();
 if (fNtinit > 0) SetNtinit(fNtinit);
}

void NcJet::AddTrack(NcTrack& t)
{
 
 
 AddTrack(t,1);
}

void NcJet::AddTrack(NcTrack& t,Int_t copy)
{
 
 if (!fTracks)
 {
  fTracks=new TObjArray(fNtmax);
  if (fTrackCopy) fTracks->SetOwner();
 }
 else if (!fTrackCopy || !copy) // Check if this track is already present
 {
  for (Int_t i=0; i<fNtrk; i++)
  {
   NcTrack* tx=(NcTrack*)fTracks->At(i);
   if (tx == &t) return;
  }
 }
 
 if (fNtrk == fNtmax) // Check if maximum track number is reached
 {
  fNtmax+=fNtinit;
  fTracks->Expand(fNtmax);
 }
 
 // Add the track to this jet
 fNtrk++;
 if (fTrackCopy && copy)
 {
  fTracks->Add(t.Clone());
 }
 else
 {
  fTracks->Add(&t);
 }
 
 fQ+=t.GetCharge();
 
 Nc4Vector p4=(Nc4Vector)t;
 Float_t tscale=t.GetEscale();
 if ((tscale/fEscale > 1.1) || (fEscale/tscale > 1.1)) p4=p4*(tscale/fEscale);
 (*this)+=p4;
 
}

void NcJet::Data(TString f,TString u)
{
 
 const char* name=GetName();
 const char* title=GetTitle();
 
 cout << " *NcJet::Data*";
 if (strlen(name))  cout << " Name : " << GetName();
 if (strlen(title)) cout << " Title : " << GetTitle();
 cout << endl;
 cout << " Id : " << fUserId << " Invmass : " << GetInvmass() << " Charge : " << fQ
      << " Momentum : " << GetMomentum() << " Energy scale : " << fEscale << " GeV" << endl;
 
 ShowTracks(0);
 
 if (fV.HasVector()) Nc4Vector::Data(f,u); 
} 

void NcJet::List(TString f,TString u,TObjArray* tracks)
{
 
 Data(f,u); // Information of the current jet
 if (fRef)   { cout << " Ref-point   :"; fRef->Data(f,u); }
 
 Int_t ntk=0;
 if (tracks)
 {
  ntk=tracks->GetEntries();
 }
 else
 {
  ntk=GetNtracks();
 }
 
 if (!ntk)
 {
  cout << " *NcJet::List* No tracks are present." << endl;
  return;
 }
 
 // The tracks of this jet
 TObject* obj;
 NcTrack* tx; 
 for (Int_t it=1; it<=ntk; it++)
 {
  if (tracks)
  {
   obj=tracks->At(it-1);
   if (!obj) continue;
   if (!obj->InheritsFrom("NcTrack")) continue;
   tx=(NcTrack*)obj;
  }
  else
  {
   tx=GetTrack(it);
   if (!tx) continue;
  }
   cout << "  ---Track no. " << it << endl;
   cout << " ";
   tx->Data(f,u); 
 }
} 

void NcJet::ListAll(TString f,TString u,TObjArray* tracks)
{
 
 Data(f,u); // Information of the current jet
 if (fRef)   { cout << " Ref-point   :"; fRef->Data(f,u); }
 
 Int_t ntk=0;
 if (tracks)
 {
  ntk=tracks->GetEntries();
 }
 else
 {
  ntk=GetNtracks();
 }
 
 if (!ntk)
 {
  cout << " *NcJet::ListAll* No tracks are present." << endl;
  return;
 }
 
 // The tracks of this jet
 TObject* obj;
 NcTrack* tx; 
 for (Int_t it=1; it<=ntk; it++)
 {
  if (tracks)
  {
   obj=tracks->At(it-1);
   if (!obj) continue;
   if (!obj->InheritsFrom("NcTrack")) continue;
   tx=(NcTrack*)obj;
  }
  else
  {
   tx=GetTrack(it);
   if (!tx) continue;
  }
   cout << "  ---Track no. " << it << endl;
   cout << " ";
   tx->ListAll(f,u); 
 }
} 

Int_t NcJet::GetNtracks(Int_t idmode,Int_t chmode,Int_t pcode)
{
 
 Int_t n=0;
 if (idmode==0 && chmode==2 && pcode==0)
 {
  return fNtrk;
 }
 else
 {
  TObjArray tracks;
  GetTracks(idmode,chmode,pcode,&tracks);
  n=tracks.GetEntries();
  return n;
 }
}

Int_t NcJet::GetNtracks(TString name,Int_t mode)
{
  
 Int_t n=0;
 
 TObjArray tracks;
 GetTracks(name,mode,&tracks);
 n=tracks.GetEntries();
 return n;
}

Double_t NcJet::GetEnergy(Float_t scale)
{
 
 Double_t E=GetScalar();
 if (E>0)
 {
  if (scale>0)
  {
   E*=fEscale/scale;
   fDresult*=fEscale/scale;
  }
  return E;
 }
 else
 {
  return 0;
 }
}

Double_t NcJet::GetMomentum(Float_t scale)
{
 
 Double_t norm=fV.GetNorm();
 fDresult=fV.GetResultError();
 if (scale>0)
 {
  norm*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 return norm;
}

Nc3Vector NcJet::Get3Momentum(Float_t scale) const
{
 
 Nc3Vector p=Get3Vector();
 if (scale>0) p*=fEscale/scale;
 return p;
}

Double_t NcJet::GetInvmass(Float_t scale)
{
 
 Double_t inv=Dot(*this);
 Double_t dinv=GetResultError();
 Double_t dm=0;
 if (inv >= 0)
 {
 Double_t m=sqrt(inv);
 if (m) dm=dinv/(2.*m);
 if (scale>0)
 {
  m*=fEscale/scale;
  dm*=fEscale/scale;
 }
 fDresult=dm;
 return m;
 }
 else
 {
  fDresult=dm;
  return 0;
 }
}

Float_t NcJet::GetCharge() const
{
 
 return fQ;
}

NcTrack* NcJet::GetTrack(Int_t i) const
{
 
 if (!fTracks) return 0;
 
 if (i<=0 || i>fNtrk)
 {
  cout << " *NcJet*::GetTrack* Invalid argument i : " << i
       << " Ntrk = " << fNtrk << endl;
  return 0;
 }
 else
 {
  return (NcTrack*)fTracks->At(i-1);
 }
}

NcTrack* NcJet::GetIdTrack(Int_t id) const
{
 
 if (!fTracks) return 0;
 
 NcTrack* tx=0;
 for (Int_t i=0; i<fNtrk; i++)
 {
  tx=(NcTrack*)fTracks->At(i);
  if (id == tx->GetId()) return tx;
 }
 return 0; // No matching id found
}

TObjArray* NcJet::GetTracks(Int_t idmode,Int_t chmode,Int_t pcode,TObjArray* tracks)
{
 
 if (tracks)
 {
  tracks->Clear();
 }
 else
 {
  if (fSelected)
  {
   fSelected->Clear();
  }
  else
  {
   fSelected=new TObjArray();
  }
 }
 
 if (!fTracks)
 {
  if (tracks)
  {
   return 0;
  }
  else
  {
   return fSelected;
  }
 }
 
 NcTrack* tx=0;
 Int_t code=0;
 Int_t id=0;
 Float_t q=0;
 for (Int_t i=0; i<fNtrk; i++)
 {
  tx=(NcTrack*)fTracks->At(i);
  if (!tx) continue;
 
  code=tx->GetParticleCode();
  if (pcode && abs(pcode)!=abs(code)) continue;
 
  id=tx->GetId();
  if (idmode==-1 && id>=0) continue;
  if (idmode==1 && id<=0) continue;
 
  q=tx->GetCharge();
  if (chmode==-1 && q>=0) continue;
  if (chmode==0 && fabs(q)>1e-10) continue;
  if (chmode==1 && q<=0) continue;
  if (chmode==3 && fabs(q)<1e-10) continue;
 
  if (tracks)
  {
   tracks->Add(tx);
  }
  else
  {
   fSelected->Add(tx);
  }
 }
 
 if (tracks)
 {
  return 0;
 }
 else
 {
  return fSelected;
 }
}

TObjArray* NcJet::GetTracks(TString name,Int_t mode,TObjArray* tracks)
{
 
 if (tracks)
 {
  tracks->Clear();
 }
 else
 {
  if (fSelected)
  {
   fSelected->Clear();
  }
  else
  {
   fSelected=new TObjArray();
  }
 }
 
 if (!fTracks)
 {
  if (tracks)
  {
   return 0;
  }
  else
  {
   return fSelected;
  }
 }
 
 NcTrack* tx=0;
 TString s;
 Int_t isel=0;
 for (Int_t i=0; i<fNtrk; i++)
 {
  tx=(NcTrack*)fTracks->At(i);
  if (!tx) continue;
 
  s=tx->GetName();
  isel=0;
  if (name=="*") isel=1;
  if (!mode && s==name) isel=1;
  if (mode==1 && s.Contains(name.Data())) isel=1;
 
  if (!isel) continue;
 
  if (tracks)
  {
   tracks->Add(tx);
  }
  else
  {
   fSelected->Add(tx);
  }
 }
 
 if (tracks)
 {
  return 0;
 }
 else
 {
  return fSelected;
 }
}

void NcJet::RemoveTrack(NcTrack* t)
{
 
 if (!t || !fTracks) return;
 
 RemoveTrack(t,1);
}

void NcJet::RemoveTracks(TString name,Int_t mode)
{
 
 if (!fTracks) return;
 
 TObjArray arr;
 GetTracks(name,mode,&arr);
 
 Int_t ntk=arr.GetEntries();
 if (!ntk) return;
 
 NcTrack* tx=0;
 for (Int_t i=0; i<ntk; i++)
 {
  tx=(NcTrack*)arr.At(i);
  if (tx) RemoveTrack(tx,0);
 }
 fTracks->Compress();
 fNtrk=fTracks->GetEntries();
}

void NcJet::RemoveTracks(Int_t idmode,Int_t chmode,Int_t pcode)
{
 
 if (!fTracks) return;
 
 TObjArray arr;
 GetTracks(idmode,chmode,pcode,&arr);
 
 Int_t ntk=arr.GetEntries();
 if (!ntk) return;
 
 NcTrack* tx=0;
 for (Int_t i=0; i<ntk; i++)
 {
  tx=(NcTrack*)arr.At(i);
  if (tx) RemoveTrack(tx,0);
 }
 fTracks->Compress();
 fNtrk=fTracks->GetEntries();
}

void NcJet::ReplaceTrack(NcTrack* told,NcTrack* tnew)
{
 
 if (!told || !tnew || !fTracks) return;
 
 Int_t index=fTracks->IndexOf(told);
 
 if (index<0 || index>=fTracks->GetEntries()) return;
 
 RemoveTrack(told,0);
 
 if (fTrackCopy)
 {
  fTracks->AddAt(tnew->Clone(),index);
 }
 else
 {
  fTracks->AddAt(tnew,index);
 }
 
 fQ+=tnew->GetCharge();
 
 Nc4Vector p4=(Nc4Vector)(*tnew);
 Float_t tscale=tnew->GetEscale();
 if ((tscale/fEscale > 1.1) || (fEscale/tscale > 1.1)) p4=p4*(tscale/fEscale);
 (*this)+=p4;
}

void NcJet::RemoveTrack(NcTrack* t,Int_t compress)
{
 
 if (!t || !fTracks) return;
 
 TObject* obj=fTracks->Remove(t);
 if (obj)
 { 
  fQ-=t->GetCharge();
  Nc4Vector p4=(Nc4Vector)(*t);
  Float_t tscale=t->GetEscale();
  if ((tscale/fEscale > 1.1) || (fEscale/tscale > 1.1)) p4=p4*(tscale/fEscale);
  (*this)-=p4;
  if (compress)
  {
   fTracks->Compress();
   fNtrk=fTracks->GetEntries();
  }
  if (fTracks->IsOwner())
  {
   delete t;
   t=0;
  }
 }
}

void NcJet::ShowTracks(Int_t mode,TString f,TString u,TObjArray* tracks)
{
 
 Int_t ntk=0;
 if (tracks)
 {
  ntk=tracks->GetEntries();
 }
 else
 {
  ntk=GetNtracks();
 }
 
 if (!ntk)
 {
  cout << " No tracks are present." << endl;
  return;
 }
 
 if (!mode)
 {
  cout << " There are " << ntk << " tracks available." << endl; 
  return;
 }
 
 if (mode==1)
 {
  cout << " The following " << ntk << " tracks are available :" << endl;
  TObject* obj=0;
  NcTrack* tx=0;
  for (Int_t i=1; i<=ntk; i++)
  {
   if (tracks)
   {
    obj=tracks->At(i-1);
    if (!obj) continue;
    if (!obj->InheritsFrom("NcTrack")) continue;
    tx=(NcTrack*)obj;
   }
   else
   {
    tx=GetTrack(i);
    if (!tx) continue;
   }
   const char* name=tx->GetName();
   const char* title=tx->GetTitle();
   cout << " Track : " << i;
   cout << " Id : " << tx->GetId();
   cout << " Q : " << tx->GetCharge() << " m : " << tx->GetMass() << " p : " << tx->GetMomentum();
   if (strlen(name)) cout << " Name : " << name;
   if (strlen(title)) cout << " Title : " << title;
   cout << endl;
  }
 }
 
 if (mode==2) List(f,u,tracks);
 
 if (mode==3) ListAll(f,u,tracks);
}

Double_t NcJet::GetPt(Float_t scale)
{
 
 Nc3Vector v;
 v=GetVecTrans();
 Double_t norm=v.GetNorm();
 fDresult=v.GetResultError();
 if (scale>0)
 {
  norm*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 
 return norm;
}

Double_t NcJet::GetPl(Float_t scale)
{
 
 Nc3Vector v;
 v=GetVecLong();
 
 Double_t pl=v.GetNorm();
 fDresult=v.GetResultError();
 
 Double_t a[3];
 v.GetVector(a,"sph");
 if (cos(a[1])<0) pl=-pl;
 if (scale>0)
 {
  pl*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 
 return pl;
}

Double_t NcJet::GetEt(Float_t scale)
{
 
 Double_t et=GetScaTrans();
 if (scale>0)
 {
  et*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 
 return et;
}

Double_t NcJet::GetEl(Float_t scale)
{
 
 Double_t el=GetScaLong();
 if (scale>0)
 {
  el*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 
 return el;
}

Double_t NcJet::GetMt(Float_t scale)
{
 
 Double_t pt=GetPt();
 Double_t dpt=GetResultError();
 Double_t m=GetInvmass();
 Double_t dm=GetResultError();
 
 Double_t mt=sqrt(pt*pt+m*m);
 Double_t dmt2=0;
 if (mt) dmt2=(pow((pt*dpt),2)+pow((m*dm),2))/(mt*mt);
 
 fDresult=sqrt(dmt2);
 if (scale>0)
 {
  mt*=fEscale/scale;
  fDresult*=fEscale/scale;
 }
 return mt;
}

Double_t NcJet::GetRapidity()
{
 
 Double_t e=GetEnergy();
 Double_t de=GetResultError();
 Double_t pl=GetPl();
 Double_t dpl=GetResultError();
 Double_t sum=e+pl;
 Double_t dif=e-pl;
 
 Double_t y=9999,dy2=0;
 if (sum && dif) y=0.5*log(sum/dif);
 
 if (sum*dif) dy2=(1./(sum*dif))*(pow((pl*de),2)+pow((e*dpl),2));
 
 fDresult=sqrt(dy2);
 return y;
}

void NcJet::SetTrackCopy(Int_t j)
{
 
 if (!fTracks)
 {
  if (j==0 || j==1)
  {
   fTrackCopy=j;
  }
  else
  {
   cout << "*NcJet::SetTrackCopy* Invalid argument : " << j << endl;
  }
 }
 else
 {
  cout << "*NcJet::SetTrackCopy* Storage already contained tracks."
       << "  ==> TrackCopy mode not changed." << endl; 
 }
}

Int_t NcJet::GetTrackCopy() const
{
 
 return fTrackCopy;
}

void NcJet::SetId(Int_t id)
{
 
 fUserId=id;
}

Int_t NcJet::GetId() const
{
 
 return fUserId;
}

void NcJet::SetReferencePoint(NcPosition& p)
{
 
 if (fRef) delete fRef;
 fRef=new NcPositionObj(p);
}

NcPosition* NcJet::GetReferencePoint()
{
 
 return fRef;
}

TObjArray* NcJet::SortTracks(Int_t mode,TObjArray* tracks,TObjArray* ordered)
{
 
 if (ordered) ordered->Clear();
 
 TObjArray* atracks=tracks;
 if (!atracks) atracks=fTracks;
 
 Int_t ntracks=0;
 if (atracks) ntracks=atracks->GetEntries();
 
 if (!mode || abs(mode)>13 || !tracks || !ntracks) return 0;
 
 if (ordered)
 {
  ordered->Expand(ntracks);
 }
 else
 {
  if (fSelected) delete fSelected;
  fSelected=new TObjArray(ntracks);
 }
 
 Double_t val1,val2; // Values of the observable to be tested upon
 TObjArray* arr=0;   // Generic sorted array pointer to be used in the logic below
 
 if (ordered)
 {
  arr=ordered;
 }
 else
 {
  arr=fSelected;
 }
 
 TObject* obj=0;
 NcTrack* tx=0;
 Int_t nord=0;
 for (Int_t i=0; i<ntracks; i++) // Loop over all tracks of the array
 {
  obj=atracks->At(i);
  if (!obj) continue;
  if (!obj->InheritsFrom("NcTrack")) continue;
  tx=(NcTrack*)obj;
 
  if (nord == 0) // store the first track at the first ordered position
  {
   nord++;
   arr->AddAt(tx,nord-1);
   continue;
  }
 
  for (Int_t j=0; j<=nord; j++) // put track in the right ordered position
  {
   if (j == nord) // track has smallest (mode<0) or largest (mode>0) observable value seen so far
   {
    nord++;
    arr->AddAt(tx,j); // add track at the end
    break; // go for next track
   }
 
   val1=0;
   val2=0;
 
   switch (abs(mode))
   {
    case 1:
     val1=tx->GetNsignals();
     val2=((NcTrack*)arr->At(j))->GetNsignals();
     break;
    case 2:
     val1=tx->GetEnergy(1);
     val2=((NcTrack*)arr->At(j))->GetEnergy(1);
     break;
    case 3:
     val1=tx->GetMomentum(1);
     val2=((NcTrack*)arr->At(j))->GetMomentum(1);
     break;
    case 4:
     val1=tx->GetMass(1);
     val2=((NcTrack*)arr->At(j))->GetMass(1);
     break;
    case 5:
     val1=tx->GetPt(1);
     val2=((NcTrack*)arr->At(j))->GetPt(1);
     break;
    case 6:
     val1=tx->GetPl(1);
     val2=((NcTrack*)arr->At(j))->GetPl(1);
     break;
    case 7:
     val1=tx->GetEt(1);
     val2=((NcTrack*)arr->At(j))->GetEt(1);
     break;
    case 8:
     val1=tx->GetEl(1);
     val2=((NcTrack*)arr->At(j))->GetEl(1);
     break;
    case 9:
     val1=tx->GetMt(1);
     val2=((NcTrack*)arr->At(j))->GetMt(1);
     break;
    case 10:
     val1=tx->GetRapidity();
     val2=((NcTrack*)arr->At(j))->GetRapidity();
     break;
    case 11:
     val1=tx->GetPseudoRapidity();
     val2=((NcTrack*)arr->At(j))->GetPseudoRapidity();
     break;
    case 12:
     val1=tx->GetCharge();
     val2=((NcTrack*)arr->At(j))->GetCharge();
     break;
    case 13:
     val1=tx->GetProb();
     val2=((NcTrack*)arr->At(j))->GetProb();
     break;
   }
 
   if (mode<0 && val1 <= val2) continue;
   if (mode>0 && val1 >= val2) continue;
 
   nord++;
   for (Int_t k=nord-1; k>j; k--) // create empty position
   {
    arr->AddAt(arr->At(k-1),k);
   }
   arr->AddAt(tx,j); // put track at empty position
   break; // go for next track
  }
 }
 
 if (ordered)
 {
  return 0;
 }
 else
 {
  return fSelected;
 }
}

Double_t NcJet::GetDistance(NcPosition* p,Float_t scale)
{
 
 Double_t dist=-1.;
 fDresult=0.;
 
 if (!p) return dist;
 
 // Obtain a defined position on this jet
 NcPosition* rx=fRef;
 
 if (!rx) return dist;
 
 Nc3Vector pj=Get3Momentum();
 
 if (pj.GetNorm() <= 0.) return dist;
 
 NcTrack tj;
 tj.Set3Momentum(pj);
 tj.SetReferencePoint(*rx);
 dist=tj.GetDistance(p,scale);
 fDresult=tj.GetResultError();
 return dist;
}

Double_t NcJet::GetDistance(NcTrack* t,Float_t scale)
{
 
 Double_t dist=-1.;
 fDresult=0.;
 
 if (!t) return dist;
 
 // Obtain a defined position on this jet
 NcPosition* rx=fRef;
 
 if (!rx) return dist;
 
 Nc3Vector pj=Get3Momentum();
 
 if (pj.GetNorm() <= 0.) return dist;
 
 NcTrack tj;
 tj.Set3Momentum(pj);
 tj.SetReferencePoint(*rx);
 dist=tj.GetDistance(t,scale);
 fDresult=tj.GetResultError();
 return dist;
}

Double_t NcJet::GetDistance(NcJet* j,Float_t scale)
{
 
 Double_t dist=-1.;
 fDresult=0.;
 
 if (!j) return dist;
 
 // Obtain a defined position on jet j
 NcPosition* rx=j->GetReferencePoint();
 
 if (!rx) return dist;
 
 Nc3Vector pj=j->Get3Momentum();
 
 if (pj.GetNorm() <= 0.) return dist;
 
 NcTrack tj;
 tj.Set3Momentum(pj);
 tj.SetReferencePoint(*rx);
 dist=GetDistance(tj,scale);
 return dist;
}

Int_t NcJet::GetNsignals(TString classname,Int_t par) const
{
 
 if (fNtrk<1) return 0;
 
 TObjArray arr;
 
 Int_t n=0;
 NcTrack* tx=0;
 Int_t exists=0;
 for (Int_t i=1; i<=fNtrk; i++)
 {
  tx=GetTrack(i);
  for (Int_t j=1; j<=tx->GetNsignals(); j++)
  {
   NcSignal* sx=tx->GetSignal(j);
   if (!sx) continue;
   exists=0;
   for (Int_t k=0; k<arr.GetEntries(); k++)
   {
    if (sx==(NcSignal*)arr.At(k))
    {
     exists=1;
     break;
    } 
   }
   if (!exists)
   {
    if ((par==0 || par==2) && sx->InheritsFrom(classname.Data()))
    {
     arr.Add(sx);
     continue;
    }
    NcDevice* parent=sx->GetDevice();
    if (!parent) continue;
    if ((par==1 || par==2) && parent->InheritsFrom(classname.Data())) arr.Add(sx);
   }
  } 
 }
 n=arr.GetEntries();
 return n;
}

TObjArray* NcJet::GetSignals(TString classname,Int_t par,TObjArray* signals)
{
 
 if (signals)
 {
  signals->Clear();
 }
 else
 {
  if (fSelected)
  {
   fSelected->Clear();
  }
  else
  {
   fSelected=new TObjArray();
  }
 }
 
 if (fNtrk<1)
 {
  if (signals)
  {
   return 0;
  }
  else
  {
   return fSelected;
  }
 }
 
 // Generic array pointer to be used in the logic below
 TObjArray* arr=0;
 if (signals)
 {
  arr=signals;
 }
 else
 {
  arr=fSelected;
 }
 
 NcTrack* tx=0;
 Int_t exists=0;
 for (Int_t i=1; i<=fNtrk; i++)
 {
  tx=GetTrack(i);
  for (Int_t j=1; j<=tx->GetNsignals(); j++)
  {
   NcSignal* sx=tx->GetSignal(j);
   if (!sx) continue;
   exists=0;
   for (Int_t k=0; k<arr->GetEntries(); k++)
   {
    if (sx==(NcSignal*)arr->At(k))
    {
     exists=1;
     break;
    } 
   }
   if (!exists)
   {
    if ((par==0 || par==2) && sx->InheritsFrom(classname.Data()))
    {
     arr->Add(sx);
     continue;
    }
    NcDevice* parent=sx->GetDevice();
    if (!parent) continue;
    if ((par==1 || par==2) && parent->InheritsFrom(classname.Data())) arr->Add(sx);
   }
  } 
 }
 
 if (signals)
 {
  return 0;
 }
 else
 {
  return fSelected;
 }
}

void NcJet::ShowSignals(TString classname,Int_t par,Int_t mode,TString f,TString u)
{
 
 TObjArray hits;
 GetSignals(classname.Data(),par,&hits);
 
 Int_t nhits=hits.GetEntries();
 
 cout << " *NcJet::ShowSignals* There are " << nhits
      << " signals recorded for (device) class " << classname.Data() << endl;
 
 if (!nhits || !mode) return;
 
 NcPosition r;
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)hits.At(i);
  if (sx) sx->Data(f,u);
  if (mode==2)
  {
   NcDevice* dev=(NcDevice*)sx->GetDevice();
   if (!dev) continue;
   r=dev->GetPosition();
   cout << "   Device Position";
   r.Data(f,u);
  }
 }
}

Double_t NcJet::GetSignalValue(TString classname,TString varname,Int_t mode,Int_t par)
{
 
 TObjArray hits;
 GetSignals(classname.Data(),par,&hits);
 
 Int_t nhits=hits.GetEntries();
 
 if (!nhits) return 0;
 
 Double_t val=0;
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)hits.At(i);
  if (!sx) continue;
  val+=sx->GetSignal(varname,mode);
 }
 
 return val;
}

void NcJet::SetEscale(Float_t scale)
{
 
 if (scale>0)
 {
  fEscale=scale;
 }
 else
 {
  cout << " *NcJet::SetEscale* Invalid scale value : " << scale << endl;
 }
}

Float_t NcJet::GetEscale() const
{
 
 return fEscale;
}

TObject* NcJet::Clone(const char* name) const
{
 
 NcJet* jet=new NcJet(*this);
 if (name)
 {
  if (strlen(name)) jet->SetName(name);
 }
 return jet;
}