IceChi2.cxx

Go to the documentation of this file.

 
#include "IceChi2.h"
#include "Riostream.h"
 
// Global pointer to the instance of this object
 IceChi2* gIceChi2=0;
 
// TFitter/Minuit interface to IceChi2::FitFCN
 void IceChi2FCN(Int_t& npar,Double_t* gin,Double_t& f,Double_t* u,Int_t flag)
 {
  if (gIceChi2) gIceChi2->FitFCN(npar,gin,f,u,flag);
 }
 
ClassImp(IceChi2); // Class implementation to enable ROOT I/O

IceChi2::IceChi2(const char* name,const char* title) : TTask(name,title)
{
 
 fFirst=1;
 fPrint=-2;
 fSelhits=2;
 fVgroup=1;
 fEvt=0;
 fUseNames=0;
 fUseNtk=0;
 fHits=0;
 fFitter=0;
 fTrackname="IceChi2";
 fCharge=0;
 fPenalty=0;
 fTkfit=0;
 fFitstats=0;
 
 // Set the global pointer to this instance
 gIceChi2=this;
}

IceChi2::~IceChi2()
{
 
 if (fUseNames)
 {
  delete fUseNames;
  fUseNames=0;
 }
 if (fUseNtk)
 {
  delete fUseNtk;
  fUseNtk=0;
 }
 if (fHits)
 {
  delete fHits;
  fHits=0;
 }
 if (fFitter)
 {
  delete fFitter;
  fFitter=0;
 }
 if (fTkfit)
 {
  delete fTkfit;
  fTkfit=0;
 }
 if (fFitstats)
 {
  delete fFitstats;
  fFitstats=0;
 }
}

void IceChi2::Exec(Option_t* opt)
{
 
 TString name=opt;
 NcJob* parent=(NcJob*)(gROOT->GetListOfTasks()->FindObject(name.Data()));
 
 if (!parent) return;
 
 fEvt=(IceEvent*)parent->GetObject("IceEvent");
 if (!fEvt) return;
 
 // Only process accepted events
 NcDevice* seldev=(NcDevice*)fEvt->GetDevice("NcEventSelector");
 if (seldev)
 {
  if (seldev->GetSignal("Select") < 0.1) return;
 }
 
 // Storage of the used parameters in the IceChi2 device
 NcDevice params;
 params.SetNameTitle("IceChi2","IceChi2 processor parameters");
 params.SetSlotName("Selhits",1);
 params.SetSlotName("Penalty",2);
 params.SetSlotName("Vgroup",3);
 
 params.SetSignal(fSelhits,1);
 params.SetSignal(fPenalty,2);
 params.SetSignal(fVgroup,3);
 
 fEvt->AddDevice(params);
 
 if (!fUseNames)
 {
  UseTracks("IceDwalkA",1);
  UseTracks("IceDwalkI",1);
 }
 
 Int_t nclasses=fUseNames->GetEntries(); // Number of first guess classes to be processed
 Int_t ntkmax=0; // Max. number of tracks for a certain class
 TObjString* strx=0;
 TString str;
 
 if (fFirst)
 {
  cout << " *IceChi2* First guess selections to be processed (-1=all)." << endl;
  for (Int_t i=0; i<nclasses; i++)
  {
   strx=(TObjString*)fUseNames->At(i);
   if (!strx) continue;
   str=strx->GetString();
   ntkmax=fUseNtk->At(i);
   cout << " Maximally " << ntkmax << " track(s) per event for procedure : " << str.Data() << endl;
  }
  cout << " *IceChi2* Hit selection mode : " << fSelhits << endl;
  cout << " *IceChi2* Penalty value for psi evaluation outside range : " << fPenalty << endl;
  cout << endl;
 
  fPsistats.SetStoreMode(1);
 
  fFirst=0;
 }
 
 const Double_t pi=acos(-1.);
 
 // Initialisation of the minimisation processor
 Double_t arglist[100];
 if (!fFitter) fFitter=new TFitter();
 
 // The number of reconstructed tracks already present in the event
 Int_t ntkreco=fEvt->GetNtracks(1);
 
 if (!fHits)
 {
  fHits=new TObjArray();
 }
 else
 {
  fHits->Clear();
 }
 
 // Initialise the basis for the fitted track(s)
 if (!fTkfit) fTkfit=new NcTrack();
 TString trackname=fTrackname;
 
 // If selected, use all the good quality hits of the complete event
 if (fSelhits==0)
 {
  TObjArray* hits=fEvt->GetHits("IceGOM");
  if (!hits) return;
  trackname+="C"; // Trackname suffix to indicate combined hit usage
  fTkfit->SetNameTitle(trackname.Data(),"IceChi2 Combined fit result");
  for (Int_t ih=0; ih<hits->GetEntries(); ih++)
  {
   NcSignal* sx=(NcSignal*)hits->At(ih);
   if (!sx) continue;
   if (sx->GetDeadValue("ADC") || sx->GetDeadValue("LE") || sx->GetDeadValue("TOT")) continue;
   fHits->Add(sx);
  }
 }
 
 // Track by track processing of the selected first guess classes
 Float_t vec[3];
 Float_t err[3];
 Nc3Vector p;
 NcPosition pos;
 if (!fFitstats)
 {
  fFitstats=new NcSignal();
  fFitstats->SetNameTitle("Fitstats","TFitter stats for Chi2 fit");
  fFitstats->SetSlotName("IERFIT",1);
  fFitstats->SetSlotName("FCN",2);
  fFitstats->SetSlotName("EDM",3);
  fFitstats->SetSlotName("NVARS",4);
  fFitstats->SetSlotName("IERERR",5);
  fFitstats->SetSlotName("PsiSum",6);
  fFitstats->SetSlotName("PsiMedian",7);
  fFitstats->SetSlotName("PsiSpread",8);
  fFitstats->SetSlotName("PsiMean",9);
  fFitstats->SetSlotName("PsiSigma",10);
 }
 Float_t x,y,z,theta,phi,t0;
 Double_t amin,edm,errdef; // Minimisation stats
 Int_t ierfit,iererr,nvpar,nparx; // Minimisation stats
 Double_t psi; // Bayesian psi value for the fitted track w.r.t. a Convoluted Pandel PDF
 Int_t ntk=0;
 Int_t nsig=0;
 NcTrack* track=0;
 Int_t amanda,inice; // Detector system indicators of associated hits
 for (Int_t iclass=0; iclass<nclasses; iclass++) // Loop over first guess classes
 {
  strx=(TObjString*)fUseNames->At(iclass);
  if (!strx) continue;
  str=strx->GetString();
  ntkmax=fUseNtk->At(iclass);
  TObjArray* tracks=fEvt->GetTracks(str);
  ntk=0;
  if (tracks) ntk=tracks->GetEntries();
  if (ntkmax>0 && ntk>ntkmax) ntk=ntkmax;
 
  for (Int_t jtk=0; jtk<ntk; jtk++) // Loop over tracks of a certain class
  {
   track=(NcTrack*)tracks->At(jtk);
   if (!track) continue;
 
   amanda=0;
   inice=0;
   trackname=fTrackname;
 
   NcPosition* r0=track->GetReferencePoint();
   if (!r0) continue;
 
   NcTimestamp* tt0=r0->GetTimestamp();
 
   // Selection of hits to be used in the fitting procedure
   if (fSelhits==1 || fSelhits==2)
   {
    fHits->Clear();
    nsig=track->GetNsignals();
    for (Int_t is=1; is<=nsig; is++)
    {
     NcSignal* sx=track->GetSignal(is);
     if (!sx) continue;
     if (!sx->GetDevice()->InheritsFrom("IceGOM")) continue;
     if (sx->GetDevice()->InheritsFrom("IceAOM")) amanda=1;
     if (sx->GetDevice()->InheritsFrom("IceIDOM")) inice=1;
     if (sx->GetDeadValue("ADC") || sx->GetDeadValue("LE") || sx->GetDeadValue("TOT")) continue;
     if (fSelhits==1) fHits->Add(sx); // Only use the associated hits
    }
    if (fSelhits==2)
    {
     TObjArray* hits=0;
     if (amanda && inice) // Combined hit usage
     {
      hits=fEvt->GetHits("IceGOM");
      trackname+="C";
      fTkfit->SetNameTitle(trackname.Data(),"IceChi2 Combined fit result");
     }
     if (amanda && !inice) // Only Amanda hit usage
     {
      hits=fEvt->GetHits("IceAOM");
      trackname+="A";
      fTkfit->SetNameTitle(trackname.Data(),"IceChi2 Amanda fit result");
     }
     if (inice && !amanda) // Only InIce hit usage
     {
      hits=fEvt->GetHits("IceIDOM");
      trackname+="I";
      fTkfit->SetNameTitle(trackname.Data(),"IceChi2 InIce fit result");
     }
     if (!hits) return;
     for (Int_t is2=0; is2<hits->GetEntries(); is2++)
     {
      NcSignal* sx=(NcSignal*)hits->At(is2);
      if (!sx) continue;
      if (sx->GetDeadValue("ADC") || sx->GetDeadValue("LE") || sx->GetDeadValue("TOT")) continue;
      fHits->Add(sx);
     }
    }
   }
   
   // Require enough hits to fit the 6 parameters
   if (fHits->GetEntries()<7) continue;
 
   r0->GetVector(vec,"car");
   r0->GetErrors(err,"car");
 
   x=vec[0];
   y=vec[1];
   z=vec[2];
 
   p=track->Get3Momentum();
   p.GetVector(vec,"sph");
 
   theta=vec[1];
   phi=vec[2];
 
   t0=fEvt->GetDifference(tt0,"ns");
   
   // Process this first guess track with its associated hits
   fFitter->Clear();
 
   // Set user selected TFitter printout level
   arglist[0]=fPrint;
   if (fPrint==-2) arglist[0]=-1;
   fFitter->ExecuteCommand("SET PRINT",arglist,1);
   if (fPrint==-2) fFitter->ExecuteCommand("SET NOWARNINGS",arglist,0);
 
   fFitter->SetFitMethod("chisquare");
 
   fFitter->SetParameter(0,"r0x",x,0.1,0,0);
   fFitter->SetParameter(1,"r0y",y,0.1,0,0);
   fFitter->SetParameter(2,"r0z",z,0.1,0,0);
   fFitter->SetParameter(3,"theta",theta,0.001,0,pi);
   fFitter->SetParameter(4,"phi",phi,0.001,0,2.*pi);
   fFitter->SetParameter(5,"t0",t0,1.,0,32000);
 
   fFitter->SetFCN(IceChi2FCN);
 
   fTkfit->Reset();
 
   arglist[0]=0;
   ierfit=fFitter->ExecuteCommand("SIMPLEX",arglist,0);
 
   fFitter->GetStats(amin,edm,errdef,nvpar,nparx);
   fFitstats->Reset();
   fFitstats->SetSignal(ierfit,1);
   fFitstats->SetSignal(amin,2);
   fFitstats->SetSignal(edm,3);
   fFitstats->SetSignal(nvpar,4);
 
   iererr=fFitter->ExecuteCommand("HESSE",arglist,0);
   fFitstats->SetSignal(iererr,5);
 
 
   // Resulting parameters after minimisation and error calculation
   vec[0]=fFitter->GetParameter(0);
   vec[1]=fFitter->GetParameter(1);
   vec[2]=fFitter->GetParameter(2);
   err[0]=fFitter->GetParError(0);
   err[1]=fFitter->GetParError(1);
   err[2]=fFitter->GetParError(2);
   pos.SetPosition(vec,"car");
   pos.SetPositionErrors(err,"car");
 
   vec[0]=1.;
   vec[1]=fFitter->GetParameter(3);
   vec[2]=fFitter->GetParameter(4);
   err[0]=0.;
   err[1]=fFitter->GetParError(3);
   err[2]=fFitter->GetParError(4);
   p.SetVector(vec,"sph");
   p.SetErrors(err,"sph");
 
   t0=fFitter->GetParameter(5);
   NcTimestamp t0fit((NcTimestamp)(*fEvt));
   t0fit.Add(0,0,int(t0));
 
   // Enter the fit result as a track in the event structure
   ntkreco++;
   fTkfit->SetId(ntkreco);
   fTkfit->SetCharge(fCharge);
   fTkfit->SetParentTrack(track);
   pos.SetTimestamp(t0fit);
   fTkfit->SetTimestamp(t0fit);
   fTkfit->SetReferencePoint(pos);
   fTkfit->Set3Momentum(p);
   for (Int_t ihit=0; ihit<fHits->GetEntries(); ihit++)
   {
    NcSignal* sx=(NcSignal*)fHits->At(ihit);
    if (sx) fTkfit->AddSignal(*sx);
   }
   psi=GetPsi(fTkfit);
   fFitstats->SetSignal(psi,6);
   fFitstats->SetSignal(fPsistats.GetMedian(1),7);
   fFitstats->SetSignal(fPsistats.GetSpread(1),8);
   fFitstats->SetSignal(fPsistats.GetMean(1),9);
   fFitstats->SetSignal(fPsistats.GetSigma(1),10);
   fTkfit->SetFitDetails(fFitstats);
   fEvt->AddTrack(fTkfit);
  } // End loop over tracks
 } // End loop over first guess classes
 
}

void IceChi2::SetPrintLevel(Int_t level)
{
 
 fPrint=level;
}

void IceChi2::UseTracks(TString classname,Int_t n)
{
 
 if (!fUseNames)
 {
  fUseNames=new TObjArray();
  fUseNames->SetOwner();
 }
 
 if (!fUseNtk) fUseNtk=new TArrayI();
 
 // Check if this classname has already been specified before 
 TString s;
 Int_t nen=fUseNames->GetEntries();
 for (Int_t i=0; i<nen; i++)
 {
  TObjString* sx=(TObjString*)fUseNames->At(i);
  if (!sx) continue;
  s=sx->GetString();
  if (s==classname) return;
 }
 
 // New classname to be added into the storage
 if (nen >= fUseNames->GetSize()) fUseNames->Expand(nen+1);
 if (nen >= fUseNtk->GetSize()) fUseNtk->Set(nen+1);
 
 TObjString* name=new TObjString();
 name->SetString(classname);
 fUseNames->Add(name);
 fUseNtk->AddAt(n,nen);
}

void IceChi2::SelectHits(Int_t mode)
{
 
 if (mode>=0 && mode<=2) fSelhits=mode;
}

void IceChi2::SetVgroupUsage(Int_t flag)
{
 
 fVgroup=flag;
}

void IceChi2::SetTrackName(TString s)
{
 
 fTrackname=s;
}

void IceChi2::SetCharge(Float_t charge)
{
 
 fCharge=charge;
}

void IceChi2::SetPenalty(Float_t val)
{
 
 fPenalty=val;
}

void IceChi2::FitFCN(Int_t&,Double_t*,Double_t& f,Double_t* x,Int_t)
{
 
 const Float_t c=0.299792458;        // Light speed in vacuum in meters per ns
 const Float_t npice=1.31768387;     // Phase refractive index (c/v_phase) of ice
 const Float_t ngice=1.35075806;     // Group refractive index (c/v_group) of ice
 const Float_t thetac=acos(1./npice);// Cherenkov angle (in radians)
 const Double_t pi=acos(-1.);
 
 // Angular reduction of complement of thetac due to v_phase and v_group difference
 Float_t alphac=0;
 if (fVgroup) alphac=atan((1.-npice/ngice)/sqrt(npice*npice-1.));
 
 // Assumed PMT timing jitter in ns
 const Double_t sigt=10;
 
 f=0;
 
 // The new r0 and p vectors and t0 from the minimisation
 Float_t vec[3];
 
 NcPosition r0;
 vec[0]=x[0];
 vec[1]=x[1];
 vec[2]=x[2];
 r0.SetPosition(vec,"car");
 
 Nc3Vector p;
 vec[0]=1;
 vec[1]=x[3];
 vec[2]=x[4];
 p.SetVector(vec,"sph");
 
 Float_t t0=x[5];
 
 // Construct a track with the new values from the minimisation
 fTkfit->SetReferencePoint(r0);
 fTkfit->Set3Momentum(p);
 
 Int_t nhits=fHits->GetEntries();
 NcPosition rhit;
 Nc3Vector r12;
 Float_t d,dist,thit,tgeo;
 Double_t tres,chi2;
 for (Int_t i=0; i<nhits; i++)
 {
  NcSignal* sx=(NcSignal*)fHits->At(i);
  if (!sx) continue;
  IceGOM* omx=(IceGOM*)sx->GetDevice();
  if (!omx) continue;
  rhit=omx->GetPosition();
  d=fTkfit->GetDistance(rhit);
  r12=rhit-r0;
  dist=p.Dot(r12)+d/tan(pi/2.-thetac-alphac);
  tgeo=t0+dist/c;
  thit=sx->GetSignal("LE",7);
  tres=thit-tgeo;
 
  // Chisquared contribution for this hit
  chi2=pow(tres/sigt,2);
 
  f+=chi2;
 }
}

Double_t IceChi2::GetPsi(NcTrack* t)
{
 
 const Float_t c=0.299792458;        // Light speed in vacuum in meters per ns
 const Float_t npice=1.31768387;     // Phase refractive index (c/v_phase) of ice
 const Float_t ngice=1.35075806;     // Group refractive index (c/v_group) of ice
 const Float_t thetac=acos(1./npice);// Cherenkov angle (in radians)
 const Float_t lambda=33.3;          // Light scattering length in ice
 const Float_t labs=98;              // Light absorbtion length in ice
 const Float_t cice=c/ngice;         // Light speed in ice in meters per ns
 const Float_t tau=557;
 const Double_t rho=((1./tau)+(cice/labs));
 const Double_t pi=acos(-1.);
 
 // Angular reduction of complement of thetac due to v_phase and v_group difference
 Float_t alphac=0;
 if (fVgroup) alphac=atan((1.-npice/ngice)/sqrt(npice*npice-1.));
 
 // Assumed PMT timing jitter in ns
 const Double_t sigma=10;
 
 Double_t psi=-1;
 
 if (!t) return psi;
 
 // The r0 and p vectors from the track
 NcPosition* ref=t->GetReferencePoint();
 Nc3Vector p=t->Get3Momentum();
 
 if (!ref || p.GetNorm()<=0) return psi;
 
 // The number of associated hits and t0 of the track
 Int_t nhits=t->GetNsignals();
 NcTimestamp* tstamp=ref->GetTimestamp();
 
 if (!nhits || !tstamp) return psi;
 
 NcPosition r0=ref->GetPosition();
 Float_t t0=fEvt->GetDifference(tstamp,"ns");
 
 NcPosition rhit;
 Nc3Vector r12;
 Float_t d,dist,thit,tgeo;
 Double_t tres,ksi,eta,pandel;
 Double_t cpandel1,cpandel2,cpandel3,cpandel;
 Double_t z,k,alpha,beta,phi,n1,n2,n3,u; // Function parameters for regions 3 and 4
 psi=0;
 Int_t ier;
 Double_t psihit=0;
 fPsistats.Reset();
 for (Int_t i=1; i<=nhits; i++)
 {
  NcSignal* sx=t->GetSignal(i);
  if (!sx) continue;
  IceGOM* omx=(IceGOM*)sx->GetDevice();
  if (!omx) continue;
  rhit=omx->GetPosition();
  d=t->GetDistance(rhit);
  ksi=d/lambda;
  r12=rhit-r0;
  dist=p.Dot(r12)+d/tan(pi/2.-thetac-alphac);
  tgeo=t0+dist/c;
  thit=sx->GetSignal("LE",7);
  tres=thit-tgeo;
 
  // The Convoluted Pandel function evaluation
  // For definitions of functions and validity regions, see the
  // CPandel writeup of O. Fadiran, G. Japaridze and N. van Eijndhoven
 
  // Move points which are outside the validity rectangle in the (tres,ksi) space
  // to the edge of the validity rectangle and signal the use of the penalty
  ier=0;
  if (tres<-25.*sigma)
  {
   tres=-25.*sigma;
   ier=1;
  }
  if (tres>3500)
  {
   tres=3500;
   ier=1;
  }
  if (ksi>50)
  {
   ksi=50;
   ier=1;
  }
 
  eta=(rho*sigma)-(tres/sigma);
 
  if (ksi<=0) // The zero distance (ksi=0) axis
  {
   cpandel=exp(-tres*tres/(2.*sigma*sigma))/(sigma*sqrt(2.*pi));
  }
  else if (ksi<=5 && tres>=-5.*sigma && tres<=30.*sigma) // The exact expression in region 1
  {
   cpandel1=pow(rho,ksi)*pow(sigma,ksi-1.)*exp(-tres*tres/(2.*sigma*sigma))/pow(2.,0.5*(1.+ksi));
   cpandel2=ROOT::Math::conf_hyperg(ksi/2.,0.5,eta*eta/2.)/TMath::Gamma((ksi+1.)/2.);
   cpandel3=sqrt(2.)*eta*ROOT::Math::conf_hyperg((ksi+1.)/2.,1.5,eta*eta/2.)/TMath::Gamma(ksi/2.);
 
   cpandel=cpandel1*(cpandel2-cpandel3);
  }
  else if (ksi<=1 && tres>30.*sigma && tres<=3500) // Approximation in region 2
  {
   pandel=pow(rho,ksi)*pow(tres,(ksi-1.))*exp(-rho*tres)/TMath::Gamma(ksi);
 
   cpandel=exp(rho*rho*sigma*sigma/2.)*pandel;
  }
  else if (ksi<=1 && tres<-5.*sigma && tres>=-25.*sigma) // Approximation in region 5
  {
   cpandel=pow(rho*sigma,ksi)*pow(eta,-ksi)*exp(-tres*tres/(2.*sigma*sigma))/(sigma*sqrt(2.*pi));
  }
  else if (ksi<=50 && tres>=0 && tres<=3500) // Approximation in region 3
  {
   z=-eta/sqrt(4.*ksi-2.);
   k=0.5*(z*sqrt(1.+z*z)+log(z+sqrt(1.+z*z)));
   alpha=-tres*tres/(2.*sigma*sigma)+eta*eta/4.-ksi/2.+0.25+k*(2.*ksi-1.);
   alpha+=-log(1.+z*z)/4.-ksi*log(2.)/2.+(ksi-1.)*log(2.*ksi-1.)/2.+ksi*log(rho)+(ksi-1.)*log(sigma);
   beta=0.5*(z/sqrt(1.+z*z)-1.);
   n1=beta*(20.*beta*beta+30.*beta+9.)/12.;
   n2=pow(beta,2.)*(6160.*pow(beta,4.)+18480.*pow(beta,3.)+19404.*pow(beta,2.)+8028.*beta+945.)/288.;
   n3=27227200.*pow(beta,6.)+122522400.*pow(beta,5.)+220540320.*pow(beta,4.);
   n3+=200166120.*pow(beta,3.)+94064328.*pow(beta,2.)+20546550.*beta+1403325.;
   n3*=pow(beta,3.)/51840.;
   phi=1.-n1/(2.*ksi-1.)+n2/pow(2.*ksi-1.,2.)-n3/pow(2.*ksi-1.,3.);
   cpandel=exp(alpha)*phi/TMath::Gamma(ksi);
  }
  else if (ksi<=50 && tres<0 && tres>=-25.*sigma) // Approximation in region 4
  {
   z=eta/sqrt(4.*ksi-2.);
   k=0.5*(z*sqrt(1.+z*z)+log(z+sqrt(1.+z*z)));
   u=exp(ksi/2.-0.25)*pow(2.*ksi-1.,-ksi/2.)*pow(2.,(ksi-1.)/2.);
   beta=0.5*(z/sqrt(1.+z*z)-1.);
   n1=beta*(20.*beta*beta+30.*beta+9.)/12.;
   n2=pow(beta,2.)*(6160.*pow(beta,4.)+18480.*pow(beta,3.)+19404.*pow(beta,2.)+8028.*beta+945.)/288.;
   n3=27227200.*pow(beta,6.)+122522400.*pow(beta,5.)+220540320.*pow(beta,4.);
   n3+=200166120.*pow(beta,3.)+94064328.*pow(beta,2.)+20546550.*beta+1403325.;
   n3*=pow(beta,3.)/51840.;
   phi=1.+n1/(2.*ksi-1.)+n2/pow(2.*ksi-1.,2.)+n3/pow(2.*ksi-1.,3.);
   cpandel=pow(rho,ksi)*pow(sigma,ksi-1.)*exp(-pow(tres,2.)/(2.*pow(sigma,2.))+pow(eta,2.)/4.)/sqrt(2.*pi);
   cpandel*=u*phi*exp(-k*(2.*ksi-1.))*pow(1.+z*z,-0.25);
  }
  else // (tres,ksi) outside validity rectangle
  {
   ier=1;
   cout << " *IceChi2::GetPsi* Outside rectangle. We should never get here." << endl;
  }
 
  // Use 10*log10 expression to obtain intuitive dB scale
  // Omit (small) negative values which are possible due to computer accuracy
  psihit=0;
  if (cpandel>0) psihit=-10.*log10(cpandel);
 
  // Penalty in dB for (tres,ksi) points outside the validity rectangle
  if (ier) psihit+=fPenalty;
 
  // Update the psi statistics for this hit
  fPsistats.Enter(float(psihit));
  psi+=psihit;
 }
 return psi;
}