NcAstrolab.cxx

Go to the documentation of this file.

 
#include "NcAstrolab.h"
#include "Riostream.h"
 
ClassImp(NcAstrolab); // Class implementation to enable ROOT I/O
 
NcAstrolab::NcAstrolab(const char* name,const char* title) : TTask(name,title),NcTimestamp()
{
 
 fExperiment="User";
 fLabId=0;
 fToffset=0;
 fRefs=0;
 fSigs=0;
 fNen[0]=0;
 fNen[1]=0;
 fBias=0;
 fGal=0;
 fIndices=0;
 fUsMeridian=0;
 fMeridian=0;
 fProj="none";
 fCanvas=0;
 fHist[0]=0;
 fHist[1]=0;
 fMarkers=0;
 fMarkerSize[0]=1.5; 
 fMarkerSize[1]=1;
 fMarkerSize[2]=1.5;
 fMarkerSize[3]=0.3;
 fMarkerStyle[0]=29;
 fMarkerStyle[1]=8;
 fMarkerStyle[2]=34;
 fMarkerStyle[3]=8;
 fMarkerColor[0]=kRed;
 fMarkerColor[1]=kBlue;
 fMarkerColor[2]=kBlack;
 fMarkerColor[3]=kBlack;
 fSkyMapPanel=0;
 fTscmode=0;
 fTscmin=0;
 fTscmax=0;
 fTscfunc=0;
 fRscmode=0;
 fDscmin=0;
 fDscmax=0;
 fDscfunc=0;
 fThetascmin=0;
 fThetascmax=0;
 fThetascfunc=0;
 fPhiscmin=0;
 fPhiscmax=0;
 fPhiscfunc=0;
 fRan=0;
 fMaxDt=-1;
 fSolUpdate=0;
 
 // Standard values (Particle Data Group 2018) for some (astro)physical parameters
 fSpeedC=299792458;
 fQe=1.602176565e-19;
 fMe=0.510998928;
 fMmu=105.6583715;
 fMtau=1776.82;
 fAmu=931.494061;
 fMp=1.007276466812*fAmu;
 fMn=1.00866491600*fAmu;
 fMW=80.385;
 fGammaW=2.085;
 fMZ=91.1876;
 fGammaZ=2.4952;
 fAlphaEM=1./137.035999074;
 fFermi=1.1663787e-5;
 fPlanck=6.62606957e-34;
 fBoltz=1.3806488e-23;
 fNewton=6.67384e-11;
 fGn=9.80665;
 fAu=1.49597870700e11;
 fPc=3.08567758149e16;
 // Cosmological parameters from the final Planck 2018 results (arXiv:1807.06209)
 fHubble=67.4;
 fOmegaM=0.315;
 fOmegaR=5.38e-5;
 fOmegaL=0.685;
 fOmegaB=0.0492;
 fOmegaC=0.264;
 
 // Some derived (astro)physical parameters c.q. conversion constants
 fHbar=6.58211928e-22;
 fHbarc=197.3269718;
 fHbarc2=3.89379338e-4;
 
 // Function to parametrize the Neutrino-Lepton kinematic opening angle
 fNuAngle=0;
 
 // Specifications of the data from a ROOT input Tree  
 fDataDir=0;
 fDataFrame="undefined";
 fDataMode="undefined";
 
 // Storage for transient burst investigations
 fBurstParameters=0;
 
 // Initialize the default values for the burst parameters
 SetBurstParameter("*",0);
 
 // Load the UTC parameters
 LoadUTCparameterFiles();
 
 // Set the default local frame convention
 // X-axis pointing South (=Greenwich)
 // Y-axis pointing East
 // Z-axis pointing towards Zenith
 SetLocalFrame(90,0,90,90,0,0);
 
 // First initialization of the various SkyMapPanel GUI parameters.
 // In case SkyMapPanel() is invoked, the current Lab settings will be imported.
 fSkyMapPanel=0;
 fMapTS.LoadUTCparameterFiles();
 for (Int_t i=0; i<3; i++)
 {
  fMapLabLBI[i]=0;
 }
 fMapLabU=0;
 fMapLabE=0;
 fMapLabLocL=0;
 fMapLabLocB=0;
 fMapLabLocU="deg";
 fMapLabExpName="User";
 fMapLabId=0;
 fMapTSdatetime=0;
 fMapTStimetype=0;
 fMapDate="";
 fMapTime="";
 fMapTimeType="-";
 fMapDateTime="";
 fMapLabTS=kTRUE;
 for (Int_t i=0; i<6; i++)
 {
  fMapLabLframe[i]=0;
 }
 fMapCinfo="Lab";
 fMapTinfo=-1;
 fMapUinfo="deg";
 fMapIname="";
 fMapEa=0;
 fMapEua="deg";
 fMapEb=0;
 fMapEub="deg";
 fMapEtype=1;
 fMapEcoord="-";
 fMapEmode="-";
 fMapEname="";
 fMapDcoord="-";
 fMapProj="-";
 fMapDmode="-";
 for (Int_t i=0; i<5; i++)
 {
  fMapDoptions[i]=kFALSE;
 }
 fMapNmax=-1;
 fMapNdigs=1;
 fMapDname="";
 for (Int_t i=0; i<10; i++)
 {
  fMapSolar[i]=kFALSE;
 }
 fMapMerMode=0;
 fMapMerC=0;
 fMapMerUc="deg";
 fMapMarkSize=1;
 fMapMarkStyle=23;
 fMapMarkColor=kRed;
 fMapMarkType=0;
}

NcAstrolab::~NcAstrolab()
{
 
 if (fRefs)
 {
  delete fRefs;
  fRefs=0;
 }
 if (fSigs)
 {
  delete fSigs;
  fSigs=0;
 }
 if (fIndices)
 {
  delete fIndices;
  fIndices=0;
 }
 for (Int_t i=0; i<2; i++)
 {
  if (fHist[i])
  {
   delete fHist[i];
   fHist[i]=0;
  }
 }
 if (fMarkers)
 {
  delete fMarkers;
  fMarkers=0;
 }
 if (fCanvas)
 {
  if (gROOT->GetListOfCanvases()->FindObject("NcAstrolab")) delete fCanvas;
  fCanvas=0;
 }
 if (fTscfunc)
 {
  delete fTscfunc;
  fTscfunc=0;
 }
 if (fDscfunc)
 {
  delete fDscfunc;
  fDscfunc=0;
 }
 if (fThetascfunc)
 {
  delete fThetascfunc;
  fThetascfunc=0;
 }
 if (fPhiscfunc)
 {
  delete fPhiscfunc;
  fPhiscfunc=0;
 }
 if (fRan)
 {
  delete fRan;
  fRan=0;
 }
 
 if (fNuAngle)
 {
  delete fNuAngle;
  fNuAngle=0;
 }
 
 if (fBurstParameters)
 {
  delete fBurstParameters;
  fBurstParameters=0;
 }
 
 // Remove the subtasks from the internal TTask list without deleting them
 if (fTasks) fTasks->Clear();
}

NcAstrolab::NcAstrolab(const NcAstrolab& t) : TTask(t),NcTimestamp(t)
{
 
 fToffset=t.fToffset;
 fLabPos=t.fLabPos;
 fLabId=t.fLabId;
 fL=t.fL;
 Int_t size=0;
 fRefs=0;
 if (t.fRefs)
 {
  size=t.fRefs->GetSize();
  fRefs=new TObjArray(size);
  for (Int_t i=0; i<size; i++)
  {
   NcSignal* sx=(NcSignal*)t.fRefs->At(i);
   if (sx) fRefs->AddAt(sx->Clone(),i);
  }
 }
 fSigs=0;
 if (t.fSigs)
 {
  size=t.fSigs->GetSize();
  fSigs=new TObjArray(size);
  for (Int_t i=0; i<size; i++)
  {
   NcSignal* sx=(NcSignal*)t.fSigs->At(i);
   if (sx) fSigs->AddAt(sx->Clone(),i);
  }
 }
 fNen[0]=t.fNen[0];
 fNen[1]=t.fNen[1];
 fBias=0;
 fGal=0;
 fIndices=0;
 fMeridian=-999;
 fProj="none";
 fCanvas=0;
 for (Int_t ih=0; ih<2; ih++)
 {
  fHist[ih]=0;
 }
 fMarkers=0;
 for (Int_t i=0; i<4; i++)
 {
  fMarkerSize[i]=t.fMarkerSize[i];
  fMarkerStyle[i]=t.fMarkerStyle[i];
  fMarkerColor[i]=t.fMarkerColor[i];
 }
 
 fTscmode=0;
 fTscmin=0;
 fTscmax=0;
 fTscfunc=0;
 SetTimeScramble(t.fTscmode,t.fTscmin,t.fTscmax,t.fTscfunc);
 
 fRscmode=0;
 fDscmin=0;
 fDscmax=0;
 fDscfunc=0;
 fThetascmin=0;
 fThetascmax=0;
 fThetascfunc=0;
 fPhiscmin=0;
 fPhiscmax=0;
 fPhiscfunc=0;
 SetPositionScramble(t.fRscmode,t.fDscmin,t.fDscmax,t.fDscfunc,t.fThetascmin,t.fThetascmax,t.fThetascfunc,t.fPhiscmin,t.fPhiscmax,t.fPhiscfunc);
 
 fRan=0;
 NcRandom* ran=t.fRan;
 if (ran) fRan=new NcRandom(*ran);
 
 fMaxDt=t.fMaxDt;
 
 TF1* fx=t.fNuAngle;
 if (fx) fNuAngle=(TF1*)fx->Clone();
 
 NcDevice* dx=t.fBurstParameters;
 if (dx) fBurstParameters=(NcDevice*)dx->Clone();
}

void NcAstrolab::Data(Int_t mode,TString u,Bool_t utc)
{
 
 TString name=GetName();
 TString title=GetTitle();
 printf(" *%-s::Data*",ClassName());
 if (name!="")  printf(" Name : %-s",name.Data());
 if (title!="") printf(" Title : %-s",title.Data());
 printf("\n");
 
 Double_t l,b;
 GetLabPosition(l,b,"deg");
 printf(" Position longitude : "); PrintAngle(l,"deg",u,3);
 printf(" latitude : "); PrintAngle(b,"deg",u,3);
 printf(" for detector ID : %-i \n",fLabId);
 printf(" Local user reference frame orientation w.r.t X0=South, Y0=East and Z0=Zenith : \n");
 printf(" (Note : At the Poles (e.g. IceCube) South means the Greenwich meridian) \n");
 TString saxes[3]={"Local X-axis","Local Y-axis","Local Z-axis"};
 for (Int_t i=0; i<5; i+=2)
 {
  printf(" %-s : zenith=",saxes[i/2].Data()); PrintAngle(fAxes[i],"deg",u,3,kTRUE);
  printf(" | phi="); PrintAngle(fAxes[i+1],"deg",u,3,kTRUE);
  printf("\n");
 }
 printf(" Lab time offset w.r.t. UT : "); PrintTime(fToffset,12);
 printf("\n");
 
 // UT and Local time info
 Date(mode,fToffset);
 
 // Add the UTC and TAI related date/time information if requested
 if (utc && mode!=4) Date(4);
 
 if (fTscmode)
 {
  printf(" ------------------ Time scrambling ----------------- \n");
  if (fTscmode<0)
  {
   printf(" *** Scrambling is applied only for off-source patch (background) data generation in MatchBurstData() *** \n");
   printf(" *** The actual stored source and measurement data are not modified *** \n");
   printf("\n");
  }
  if (abs(fTscmode)==1)
  {
   printf(" *** Each obtained time difference will be scrambled (mode %-i) *** \n",fTscmode);
   printf(" *** The angular differences are not affected *** \n");
   printf(" --> Tailored for scrambling entries in a specific time window without affecting \n");
   printf("     the event selection based on angular separation w.r.t. a source. \n");
  }
  if (abs(fTscmode)==2)
  {
   if (fTscmode>0)
   {
    printf(" *** Each measurement is stored with a scrambled timestamp (mode %-i) *** \n",fTscmode);
    printf(" *** The data of the sources are not modified *** \n");
    printf(" *** Off-source (background) data : At each source matching, the measurement is given a new scrambled fake timestamp *** \n");
    printf(" --> Tailored for blind analyses without access to the unblinded measurement data \n");
   }
   else
   {
    printf(" *** At each source matching, the measurement is given a new scrambled fake timestamp (mode %-i) *** \n",fTscmode);
   }
   printf(" --> Possible patterns in the distribution of sources on the sky will stay intact \n");
  }
  if (abs(fTscmode)==3)
  {
   printf(" *** At each measurement matching, the source is retrieved from the storage with a scrambled fake timestamp (mode %-i) *** \n",fTscmode);
   printf(" *** The measurements are not affected --> Detection efficiency is unaltered *** \n"); 
   printf(" --> Both time and angular differences will be scrambled \n"); 
   printf(" --> Possible patterns in the distribution of sources on the sky will be washed out \n");
  }
  TString sx="offsets";
  if (abs(fTscmode)==1) sx="differences";
  printf(" Time %-s are randomly drawn from the interval [%-g,%-g] sec. \n",sx.Data(),fTscmin,fTscmax);
  if (fTscfunc)
  {
   printf(" Randomising TF1 function %-s is used. \n",fTscfunc->GetName());
  }
  else
  {
   printf(" Uniform randomisation is used. \n");
  }
 }
 
 if (fRscmode)
 {
  printf(" ------------------ Position scrambling ------------------ \n");
  if (fRscmode<0)
  {
   printf(" *** Scrambling is applied only for off-source patch (background) data generation in MatchBurstData() *** \n");
   printf(" *** The actual stored source and measurement data are not modified *** \n");
  }
  else
  {
   printf(" *** The data of the sources and the measurement timestamps are not modified *** \n");
  }
  printf("\n");
 
  if (abs(fRscmode)==1)
  {
   printf(" *** Each obtained angular difference will be scrambled (mode %-i) *** \n",fRscmode);
   printf(" *** The time differences are not affected *** \n");
   printf(" ---> Tailored for scrambling entries within a specific angular range w.r.t. a source,");
   printf("      without affecting the event selection based on the time difference w.r.t. a transient source. \n");
   printf(" Angular differences are randomly drawn from the interval [%-g,%-g] degrees. \n",fDscmin,fDscmax);
   if (fDscfunc)
   {
    printf(" Randomising TF1 function %-s is used. \n",fDscfunc->GetName());
   }
   else
   {
    printf(" Homogeneous solid angle randomisation is used. \n");
   }
  }
 
  if (fRscmode==2)
  {
    printf(" *** Each measurement is stored with a scrambled fake local position (mode %-i) *** \n",fRscmode);
    printf(" *** Off-source (background) data : At each source matching, the measurement is given a new scrambled fake local position *** \n");
    printf(" --> Tailored for blind analyses without access to the unblinded measurement data \n");
  }
 
  if (abs(fRscmode)==3 || fRscmode==-2)
  {
   printf(" *** At each source matching, the measurement is given a new scrambled fake local position (mode %-i) *** \n",fRscmode);
  }
 
  if (abs(fRscmode)>1)
  {
   printf(" The local coordinates (r,theta,phi) of the measurement are modified to (r+dr,theta+dtheta,phi+dphi) with : \n");
 
   printf(" dr is randomly drawn from the interval [%-g,%-g] \n",fDscmin,fDscmax);
   if (fDscfunc)
   {
    printf(" Randomising TF1 function %-s is used. \n",fDscfunc->GetName());
   }
   else
   {
    printf(" Uniform randomisation is used. \n");
   }
 
   printf(" dtheta is randomly drawn from the interval [%-g,%-g] degrees. \n",fThetascmin,fThetascmax);
   if (fThetascfunc)
   {
    printf(" Randomising TF1 function %-s is used. \n",fThetascfunc->GetName());
   }
   else
   {
    printf(" Uniform cos(theta) randomisation is used. \n");
   }
 
   printf(" dphi is randomly drawn from the interval [%-g,%-g] degrees. \n",fPhiscmin,fPhiscmax);
   if (fPhiscfunc)
   {
    printf(" Randomising TF1 function %-s is used. \n",fPhiscfunc->GetName());
   }
   else
   {
    printf(" Uniform phi randomisation is used. \n");
   }
  }
 }
 
 printf(" ------------------ \n");
 if (fRan)
 {
  Int_t iseed,cnt1,cnt2;
  GetRandomiser(iseed,cnt1,cnt2);
  cout << " *** Current settings of the internal NcRandom randomiser : iseed=" << iseed << " cnt1=" << cnt1 << " cnt2=" << cnt2 << endl;
 }
 else
 {
  cout << " *** The internal NcRandom randomiser is currently not intialised ***" << endl;
  cout << " Automatic initialisation will be performed with the actual timestamp at the first random number request." << endl;
  cout << " This will ensure different random sequences for different NcAstrolab instances." << endl;
  cout << " To obtain reproducible scrambled results, please invoke SetRandomiser() before the first SetSignal() invokation." << endl;
 }
 printf(" ------------------ \n");
}

void NcAstrolab::SetLabPosition(Nc3Vector& p)
{
 
 fLabPos.SetPosition(p);
 
 // Determine local time offset in fractional hours w.r.t. UT.
 Double_t vec[3];
 p.GetVector(vec,"sph","deg");
 Double_t l=vec[2];
 fToffset=l/15.;
}

void NcAstrolab::SetLabPosition(Double_t l,Double_t b,TString u)
{
 
 Double_t r=1,theta=0,phi=0;
 
 l=ConvertAngle(l,u,"deg");
 b=ConvertAngle(b,u,"deg");
 
 Double_t offset=90.;
 
 theta=offset-b;
 phi=l;
 
 Double_t p[3]={r,theta,phi};
 fLabPos.SetPosition(p,"sph","deg");
 
 // Local time offset in fractional hours w.r.t. UT.
 fToffset=l/15.;
}

void NcAstrolab::SetExperiment(TString name,Int_t id)
{
 
 fExperiment="User";
 fLabId=0;
 
 Double_t l=0; // Longitude
 Double_t b=0; // Lattitude
 
 if (name=="User")
 {
  SetNameTitle("User","Virtual Lab for general use");
  SetLabPosition(0,90,"deg"); // North Pole
  // Right handed local grid frame has X-South (to Greenwich), Y-East and Z-Zenith
  // which is the same as the Master Reference Frame (MRF)
  SetLocalFrame(90,0,90,90,0,0);
  fExperiment=name;
  fLabId=id;
  return;
 }
 
 if (name=="Greenwich")
 {
  // Exact location : 51d 28' 36.6672" (N) and 0d 0' 1.8000" (W)
  SetNameTitle("Greenwich","The Royal Observatory in the UK");
  l=-0.000500;
  b=51.476852;
  SetLabPosition(l,b,"deg"); // South Pole
  // Right handed Greenwich local grid frame has X-South, Y-East and Z-Zenith
  // which is the same as the Master Reference Frame (MRF)
  SetLocalFrame(90,0,90,90,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="Amanda")
 {
  SetNameTitle("Amanda","Antarctic Muon And Neutrino Detector Array");
  SetLabPosition(0,-90,"deg"); // South Pole
  // Right handed Amanda local grid frame has Y-North (to Greenwich), X-East and Z-Zenith
  SetLocalFrame(90,90,90,180,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="IceCube")
 {
  // Exact location : 89d 59' 23.977" (S) and 63d 37' 21.432" (W)
  SetNameTitle("IceCube","The South Pole Neutrino Observatory");
  l=-63.453056;
  b=-89.99;
  SetLabPosition(l,b,"deg"); // South Pole
  // Right handed IceCube local grid frame has Y-North (to Greenwich), X-East and Z-Zenith
  SetLocalFrame(90,90.+l,90,180.+l,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="WSRT")
 {
  SetNameTitle("WSRT","The Westerbork Synthesis Radio Telescope");
  SetLabPosition(63612.74,525454.33,"dms");
  // Right handed local grid frame has X-South, Y-East and Z-Zenith
  // which is the same as the Master Reference Frame (MRF)
  SetLocalFrame(90,0,90,90,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="Astron")
 {
  SetNameTitle("Astron","The Netherlands Institute for Radio Astronomy");
  SetLabPosition(62346.23,524843.99,"dms");
  // Right handed local grid frame has X-South, Y-East and Z-Zenith
  // which is the same as the Master Reference Frame (MRF)
  SetLocalFrame(90,0,90,90,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="ARA")
 {
  SetNameTitle("ARA","The Askaryan Radio Array at the South Pole");
  SetLabPosition(0,-90,"deg"); // South Pole
  // Right handed ARA local grid frame has Y-North (to Greenwich), X-East and Z-Zenith
  SetLocalFrame(90,90,90,180,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="RNO-G")
 {
  SetNameTitle("RNO-G","The Greenland Radio Neutrino Observatory at Summit Station");
  // Use the location of the Big House as global location
  l=-38.4604;
  b=72.57889;
 
  // The locations of the various stations
  Int_t ids[35]={11,12,13,14,15,16,17,21,22,23,24,25,26,27,33,34,35,36,37,44,45,46,47,54,55,56,57,64,65,66,67,74,75,76,77};
  Float_t ls[35]={-38.5023,-38.4962,-38.4901,-38.4841,-38.4780,-38.4719,-38.4657,-38.4660,-38.4599,-38.4538,-38.4477,-38.4416,-38.4355,-38.4293, /*last is 27*/
                  -38.4175,-38.4114,-38.4053,-38.3991,-38.3930,-38.3751,-38.3689,-38.3627,-38.3566,-38.3388,-38.3326,-38.3264,-38.3202,-38.3025, /*last is 64*/
                  -38.2963,-38.2900,-38.2838,-38.2662,-38.2599,-38.2537,-38.2474};
  Float_t bs[35]={72.58923,72.60009,72.61095,72.62181,72.63267,72.64353,72.65439,72.58741,72.59827,72.60912,72.61998,72.63084,72.64170,72.65256, /*last is 27*/  
                  72.60729,72.61815,72.62901,72.63987,72.65073,72.61631,72.62717,72.63803,72.64889,72.61447,72.62533,72.63618,72.64704,72.61262, /*last is 64*/
                  72.62347,72.63433,72.64518,72.61076,72.62161,72.63247,72.64332};
 
  // Select a specific station, if requested
  if (id)
  {
   for (Int_t i=0; i<35; i++)
   {
    if (id==ids[i])
    {
     l=ls[i];
     b=bs[i];
     fLabId=id;
     break;
    }
   }
  }
 
  // Set the selected location
  SetLabPosition(l,b,"deg"); // Summit Station
  // Right handed RNO-G local grid frame has Y-North, X-East and Z-Zenith
  SetLocalFrame(90,90,90,180,0,0);
  fExperiment=name;
  return;
 }
 
 if (name=="ARCA")
 {
  SetNameTitle("ARCA","The KM3NeT/ARCA Neutrino detector near Sicily");
  SetLabPosition(155842.25,361748.34,"dms");
  // Right handed ARCA local grid frame has Y-North, X-East and Z-Zenith
  SetLocalFrame(90,90,90,180,0,0);
  fExperiment=name;
  return;
 }
 
 cout << " *" << ClassName() << "::SetExperiment* Unsupported experiment name : " << name.Data() << endl;
 printf(" Experiment is set to %-s with detector identifier %-i \n",fExperiment.Data(),fLabId);
}

void NcAstrolab::SetLabTimeOffset(Double_t dt)
{
 
 fToffset=dt;
}

NcPosition NcAstrolab::GetLabPosition() const
{
 
 return fLabPos;
}

void NcAstrolab::GetLabPosition(Double_t& l,Double_t& b,TString u) const
{
 
 Double_t pi=acos(-1.);
 
 Double_t offset=90.;
 if (u=="rad") offset=pi/2.;
 
 Double_t p[3];
 fLabPos.GetPosition(p,"sph",u);
 b=offset-p[1];
 l=p[2];
}

TString NcAstrolab::GetExperiment() const
{
 
 return fExperiment;
}

Int_t NcAstrolab::GetLabDetectorId() const
{
 
 return fLabId;
}

Double_t NcAstrolab::GetLabTimeOffset() const
{
 
 return fToffset;
}

void NcAstrolab::SetRandomiser(Int_t iseed,Int_t cnt1,Int_t cnt2,NcTimestamp* ts)
{
 
 if (!ts) ts=(NcTimestamp*)this;
 
 if (fRan) delete fRan;
 
 fRan=new NcRandom(iseed,cnt1,cnt2,ts);
}

NcRandom* NcAstrolab::GetRandomiser(Int_t& iseed,Int_t& cnt1,Int_t& cnt2) const
{
 
 iseed=-1;
 cnt1=-1;
 cnt2=-1;
 
 if (!fRan) return 0;
 
 iseed=fRan->GetSeed();
 cnt1=fRan->GetCnt1();
 cnt2=fRan->GetCnt2();
 
 return fRan;
}

void NcAstrolab::SetMaxDt(Double_t s)
{
 
 fMaxDt=s;
}

Double_t NcAstrolab::GetMaxDt() const
{
 
 return fMaxDt;
}

Double_t NcAstrolab::GetLT()
{
 
 Double_t h=GetLT(fToffset);
 return h;
}

Double_t NcAstrolab::GetLMST()
{
 
 Double_t h=GetLMST(fToffset);
 return h;
}

Double_t NcAstrolab::GetLAST()
{
 
 Double_t h=GetLAST(fToffset);
 return h;
}

void NcAstrolab::PrintAngle(Double_t a,TString in,TString out,Int_t ndig,Bool_t align) const
{
 
 Double_t b=ConvertAngle(a,in,out);
 
 if (out=="deg" || out=="rad")
 {
  if (align)
  {
   printf("%*.*f %-s",5+ndig,ndig,b,out.Data());
  }
  else
  {
   printf("%-.*f %-s",ndig,b,out.Data());
  }
  return; 
 }
 
 Double_t epsilon=1.e-12; // Accuracy in (arc)seconds
 Int_t word=0,ddd=0,hh=0,mm=0,ss=0;
 Double_t s;
 
 if (out=="dms")
 {
  word=Int_t(b);
  word=abs(word);
  ddd=word/10000;
  word=word%10000;
  mm=word/100;
  ss=word%100;
  s=fabs(b)-Double_t(ddd*10000+mm*100+ss);
  if (s>(1.-epsilon))
  {
   s=0.;
   ss++;
  }
  while (ss>=60)
  {
   ss-=60;
   mm++;
  }
  while (mm>=60)
  {
   mm-=60;
   ddd++;
  }
  while (ddd>=360)
  {
   ddd-=360;
  }
  if (b<0) ddd=-ddd;
  s+=double(ss);
  if (align)
  {
   if (!ddd && b<0)
   {
    printf("  -0d %02i' %0*.*f\"",mm,3+ndig,ndig,s);
   }
   else
   {
    printf("%4id %02i' %0*.*f\"",ddd,mm,3+ndig,ndig,s);
   }
  }
  else
  {
   if (!ddd && b<0)
   {
    printf("-0d %-i' %-.*f\"",mm,ndig,s);
   }
   else
   {
    printf("%-id %-i' %-.*f\"",ddd,mm,ndig,s);
   }
  }
  return;
 }
 
 if (out=="hms")
 {
  word=Int_t(b);
  word=abs(word);
  hh=word/10000;
  word=word%10000;
  mm=word/100;
  ss=word%100;
  s=fabs(b)-Double_t(hh*10000+mm*100+ss);
  if (s>(1.-epsilon))
  {
   s=0.;
   ss++;
  }
  while (ss>=60)
  {
   ss-=60;
   mm++;
  }
  while (mm>=60)
  {
   mm-=60;
   hh++;
  }
  while (hh>=24)
  {
   hh-=24;
  }
  if (b<0) hh=-hh;
  s+=double(ss);
  if (align)
  {
   if (!hh && b<0)
   {
    printf(" -0h %02im %0*.*fs",mm,3+ndig,ndig,s);
   }
   else
   {
    printf("%3ih %02im %0*.*fs",hh,mm,3+ndig,ndig,s);
   }
  }
  else
  {
   if (!hh && b<0)
   {
    printf("-0h %-im %-.*fs",mm,ndig,s);
   }
   else
   {
    printf("%-ih %-im %-.*fs",hh,mm,ndig,s);
   }
  }
  return;
 }
}

NcSignal* NcAstrolab::SetSignal(Nc3Vector* r,TString frame,TString mode,NcTimestamp* ts,Int_t jref,TString name,Int_t type)
{
 
 // Cope with the (obsolete) jref=0 specification
 if (!jref)
 {
  type=1;
  jref=1;
  delete fSigs;
  fSigs=0;
 }
 
 if (!r) return 0;
 
 if (!r->HasVector()) return 0;
 
 if (frame!="equ" && frame!="gal" && frame!="ecl" && frame!="hor" && frame!="icr" && frame!="loc") return 0;
 
 if (frame=="equ" && mode!="M" && mode!="m" && mode!="T" && mode!="t" && mode!="B" && mode!="b" && mode!="J" && mode!="j") return 0;
 
 NcSignal* sx=0;
 
 if (!ts) ts=(NcTimestamp*)this;
 
 // Make a local copy of the timestamp to make sure that the newly stored
 // signal will never contain the Tree with the UTCparameter data.
 NcTimestamp ts2;
 Int_t mjd=0;
 Int_t isec=0;
 Int_t ins=0;
 Int_t ips=0;
 ts->GetMJD(mjd,isec,ins);
 ips=ts->GetPs();
 ts2.SetMJD(mjd,isec,ins,ips);
 
 Double_t vec[3];
 vec[0]=r->GetX(1,"sph","rad");
 vec[1]=r->GetX(2,"sph","rad");
 vec[2]=r->GetX(3,"sph","rad");
 Nc3Vector q;
 q.SetVector(vec,"sph","rad"); 
 
 // Recursive invokation in case of local coordinates
 if (frame=="loc")
 {
  // Convert to horizontal coordinates
  q=q.GetUnprimed(&fL);
 
  // Store the signal
  sx=SetSignal(&q,"hor",mode,&ts2,jref,name,type);
  return sx;
 }
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // with identical measurements and reference signals without explicit initialisation
 // of the randomiser by the user at the start of the analysis.
 if (!fRan && type && (fTscmode==2 || fRscmode==2)) fRan=new NcRandom(-1);
 
 // Local timestamp copy to allow time scrambling
 NcTimestamp tx(ts2);
 
 // Perform time scrambling (measurements only) if requested
 if (type && fTscmode==2)
 {
  Double_t dt=0;
 
  // Allow for specific offset studies
  if (fTscmin==fTscmax) dt=fTscmin;
 
  // Go for randomly scrambled values
  if (fTscfunc)
  {
   if (fTscmax>fTscmin)
   {
    dt=fTscfunc->GetRandom(fTscmin,fTscmax);
   }
  }
  else
  {
   if (fTscmax>fTscmin) dt=fRan->Uniform(fTscmin,fTscmax);
  }
  tx.AddSec(dt);
 }
 
 // Construct the corresponding ICRS position vector to be stored
 if (frame=="equ")
 {
  // Convert to "mean" values at specified epoch
  if (mode=="T" || mode=="t")
  {
   SetNmatrix(&tx);
   q=q.GetUnprimed(&fN);
  }
 
  // Convert to "mean" values at J2000
  if (mode=="T" || mode=="t" || mode=="M" || mode=="m")
  {
   SetPmatrix(&tx);
  }
  else
  {
   NcTimestamp te;
   if (mode=="B" || mode=="b") te.SetEpoch(1950,"B");
   if (mode=="J" || mode=="j") te.SetEpoch(2000,"J");
   SetPmatrix(&te);
  }
  q=q.GetUnprimed(&fP);
 
  // Convert to ICRS values
  if (!fBias) SetBmatrix(); 
  q=q.GetUnprimed(&fB);
 }
 
 if (frame=="gal")
 {
  // Convert to J2000 equatorial mean coordinates
  if (fGal != 2) SetGmatrix("J");
  q=q.GetUnprimed(&fG);
 
  // Convert to ICRS values
  if (!fBias) SetBmatrix(); 
  q=q.GetUnprimed(&fB);
 }
 
 if (frame=="ecl")
 {
  // Convert to mean equatorial values at specified epoch
  SetEmatrix(&tx);
  q=q.GetUnprimed(&fE);
 
  // Convert to "mean" values at J2000
  SetPmatrix(&tx);
  q=q.GetUnprimed(&fP);
 
  // Convert to ICRS values
  if (!fBias) SetBmatrix(); 
  q=q.GetUnprimed(&fB);
 }
 
 if (frame=="hor")
 {
  // Convert to "true" equatorial values at the specified timestamp
  SetHmatrix(&tx);
  q=q.GetUnprimed(&fH);
 
  // Convert to "mean" values at specified timestamp
  SetNmatrix(&tx);
  q=q.GetUnprimed(&fN);
 
  // Convert to "mean" values at J2000
  SetPmatrix(&tx);
  q=q.GetUnprimed(&fP);
 
  // Convert to ICRS values
  if (!fBias) SetBmatrix(); 
  q=q.GetUnprimed(&fB);
 }
 
 // Store the signal in ICRS coordinates
 Int_t size=0;
 Int_t jmax=0;
 Int_t jlast=0;
 if (type) // Storage of a measurement
 {
  NcSignal* sxsig=0;
  if (!fSigs) 
  {
   fSigs=new TObjArray();
   fSigs->SetOwner();
  }
  // Expand array size if needed
  size=fSigs->GetSize();
  jmax=size-1;
  jlast=fSigs->GetLast();
  if (jref>0)
  {
   if (jref>size) fSigs->Expand(jref);
  }
  else
  {
   if (jlast==jmax) fSigs->Expand(size+1);
  }
  sxsig=GetSignal(jref,type);
  if (!sxsig)
  {
   sxsig=new NcSignal();
  }
  else
  {
   sxsig->Reset(1);
  }
  if (name=="") // Generate a corresponding measurement name
  {
   fNen[1]++;
   name="Meas";
   name+=fNen[1];
   name+="#";
  }
  sxsig->SetName(name);
  sxsig->SetTitle("Observed event in ICRS coordinates");
  sxsig->SetTimestamp(tx);
  sxsig->SetPosition(q);
  if (jref<0)
  {
   fSigs->Add(sxsig);
  }
  else
  {
   fSigs->AddAt(sxsig,jref-1);
  }
  sx=sxsig;
 }
 else // Storage of a reference signal
 {
  NcSignal* sxref=0;
  if (!fRefs) 
  {
   fRefs=new TObjArray();
   fRefs->SetOwner();
  }
  // Expand array size if needed
  size=fRefs->GetSize();
  jmax=size-1;
  jlast=fRefs->GetLast();
  if (jref>0)
  {
   if (jref>size) fRefs->Expand(jref);
  }
  else
  {
   if (jlast==jmax) fRefs->Expand(size+1);
  }
  sxref=GetSignal(jref,type);
  if (!sxref)
  {
   sxref=new NcSignal();
  }
  else
  {
   sxref->Reset(1);
  }
  if (name=="") // Generate a corresponding reference name
  {
   fNen[0]++;
   name="Ref";
   name+=fNen[0];
   name+="#";
  }
  sxref->SetName(name);
  sxref->SetTitle("Reference event in ICRS coordinates");
  sxref->SetTimestamp(tx);
  sxref->SetPosition(q);
  if (jref<0)
  {
   fRefs->Add(sxref);
  }
  else
  {
   fRefs->AddAt(sxref,jref-1);
  }
  sx=sxref;
 }
 
 if (fRscmode !=2 || !type) return sx;

 // Perform position scrambling (measurements only) if requested //
 
 // Get the measurement in local coordinates
 Int_t index=fSigs->IndexOf(sx);
 index++; // First storage is at index=1 and not index=0
 GetSignal(q,"loc",mode,&tx,index,type);
 
 q.GetVector(vec,"sph","deg"); 
 
 Double_t dd=0;
 Double_t dtheta=0;
 Double_t dphi=0;
 
 // Allow specific offset studies
 if (fDscmin==fDscmax) dd=fDscmin;
 if (fThetascmin==fThetascmax) dtheta=fThetascmin;
 if (fPhiscmin==fPhiscmax) dphi=fPhiscmin;
 
 // Go for randomly scrambled values
 if (fDscfunc)
 {
  if (fDscmax>fDscmin)
  {
   dd=fDscfunc->GetRandom(fDscmin,fDscmax);
  }
 }
 else 
 {
  if (fDscmax>fDscmin) dd=fRan->Uniform(fDscmin,fDscmax);
 }
 
 if (fThetascfunc)
 {
  if (fThetascmax>fThetascmin)
  {
   dtheta=fThetascfunc->GetRandom(fThetascmin,fThetascmax);
  }
 }
 else if (fThetascmax>fThetascmin)
 {
  Double_t pi=acos(-1.);
  Float_t cosmin=cos(fThetascmin*pi/180.);
  Float_t cosmax=cos(fThetascmax*pi/180.);
  if (cosmin>cosmax)
  {
   Float_t temp=cosmin;
   cosmin=cosmax;
   cosmax=temp;
  }
  Double_t cosang=fRan->Uniform(cosmin,cosmax);
  dtheta=acos(cosang)*180./pi;
 }
 
 if (fPhiscfunc)
 {
  if (fPhiscmax>fPhiscmin)
  {
   dphi=fPhiscfunc->GetRandom(fPhiscmin,fPhiscmax);
  }
 }
 else
 {
  if (fPhiscmax>fPhiscmin) dphi=fRan->Uniform(fPhiscmin,fPhiscmax);
 }
 
 vec[0]+=dd;
 if (vec[0]<=0) vec[0]=1e-20; // Keep a physical situation
 vec[1]+=dtheta;
 vec[2]+=dphi;
 q.SetVector(vec,"sph","deg");

 // Construct the corresponding ICRS position vector to be stored //
 
 // Convert to horizontal coordinates
 q=q.GetUnprimed(&fL);
 
 // Convert to "true" equatorial values at the specified timestamp
 SetHmatrix(&tx);
 q=q.GetUnprimed(&fH);
 
 // Convert to "mean" values at specified timestamp
 SetNmatrix(&tx);
 q=q.GetUnprimed(&fN);
 
 // Convert to "mean" values at J2000
 SetPmatrix(&tx);
 q=q.GetUnprimed(&fP);
 
 // Convert to ICRS values
 if (!fBias) SetBmatrix(); 
 q=q.GetUnprimed(&fB);
 
 // Store the measurement position
 sx->SetPosition(q);
 
 return sx;
}

Int_t NcAstrolab::SetSolarSystem(TString name,NcTimestamp* ts,Int_t type)
{
 
 // Only geocentric positions are allowed
 if (name.Contains("*")) return 0;
 
 if (!ts) ts=(NcTimestamp*)this;
 
 Double_t lx=0; // Geocentric ecliptic longitude of the object in degrees
 Double_t bx=0; // Geocentric ecliptic latitude of the object in degrees
 Double_t rx=0; // Distance (AU for planets, km for the Moon) between the object and the Earth.
 
 Int_t set=0; // Flag to indicate that a location has been set
 
 ts->Almanac(0,0,0,0,name,&lx,&bx,&rx);
 
 if (rx>0) set=1;
 
 // Replace c.q. store the object data as a reference or measured signal according to "type".
 // In case the object wasn't stored yet, jref=-1 and the object will be 
 // added to the list of stored signals of "type".
 Int_t jref=GetSignalIndex(name,type);
 if (set && jref) SetSignal(rx,lx,"deg",bx,"deg","ecl",ts,jref,"M",name,type);
 
 return set;
}

NcSignal* NcAstrolab::SetSignal(Double_t d,Double_t a,TString au,Double_t b,TString bu,TString frame,NcTimestamp* ts,Int_t jref,TString mode,TString name,Int_t type)
{
 
 // Assure physical value for the norm of the location vector 
 if (d<=0) d=1;
 
 // Convert angular coordinates to fractional degrees.
 a=ConvertAngle(a,au,"deg");
 b=ConvertAngle(b,bu,"deg");
 
 Nc3Vector r;
 Double_t vec[3]={0,0,0};
 vec[0]=d;
 
 // Equatorial coordinates
 if (frame=="equ")
 {
  if (mode!="M" && mode!="m" && mode!="T" && mode!="t" && mode!="B" && mode!="b" && mode!="J" && mode!="j") return 0;
  vec[1]=90.-b;
  vec[2]=a;
 }
 
 // Galactic coordinates
 if (frame=="gal")
 {
  vec[1]=90.-b;
  vec[2]=a;
 }
 
 // Geocentric ecliptic coordinates
 if (frame=="ecl")
 {
  vec[1]=90.-b;
  vec[2]=a;
 }
 
 // Horizontal coordinates
 if (frame=="hor")
 {
  vec[1]=b;
  vec[2]=180.-a;
 }
 
 // ICRS coordinates
 if (frame=="icr")
 {
  vec[1]=90.-b;
  vec[2]=a;
 }
 
 // Local coordinates
 if (frame=="loc" || frame=="pdir")
 {
  vec[1]=a;
  vec[2]=b;
 }
 
 if (!ts) ts=(NcTimestamp*)this;
 
 r.SetVector(vec,"sph","deg");
 
 // Revert momentum direction in order to get the source direction 
 if (frame=="pdir")
 {
  r*=-1.;
  frame="loc";
 }
 
 NcSignal* sx=SetSignal(&r,frame,mode,ts,jref,name,type);
 return sx;
}

NcSignal* NcAstrolab::SetSignal(Double_t d,Double_t a,TString au,Double_t b,TString bu,TString frame,TString s,Double_t e,Int_t jref,TString mode,TString name,Int_t type)
{
 
 NcTimestamp tx;
 tx.SetEpoch(e,s);
 
 NcSignal* sx=SetSignal(d,a,au,b,bu,frame,&tx,jref,mode,name,type);
 return sx;
}

Int_t NcAstrolab::SetSourceAttributes(NcSignal* s,Double_t sigmapos,TString u,Double_t z,Double_t T90)
{
 
 if (!s) return 0;
 
 Int_t n=3;
 
 if (sigmapos<0)
 {
  sigmapos=-999;
  n--;
 }
 if (z<0)
 {
  z=-999;
  n--;
 }
 if (T90<0)
 {
  T90=-999;
  n--;
 }
 
 // Convert the position uncertainty into degrees
 Double_t sigma=ConvertAngle(sigmapos,u,"deg");
 
 s->AddNamedSlot("csigma");
 s->AddNamedSlot("z");
 s->AddNamedSlot("T90");
 s->SetSignal(sigma,"csigma");
 s->SetSignal(z,"z");
 s->SetSignal(T90,"T90");
 
 return n;
}

Double_t NcAstrolab::GetSourceAttributes(NcSignal* s,Float_t* z,Float_t* T90)
{
 
 if (!s) return -999;
 
 Double_t sigma=s->GetSignal("csigma");
 if (z) *z=s->GetSignal("z");
 if (T90) *T90=s->GetSignal("T90");
 
 return sigma;
}

Int_t NcAstrolab::GetNRefSignals(Int_t mode) const
{
 
 Int_t n=GetNsignals(0,mode);
 return n;
}

Int_t NcAstrolab::GetNsignals(Int_t type,Int_t mode) const
{
 
 TObjArray* arr=fRefs;
 if (type) arr=fSigs;
 
 if (!arr) return 0;
 
 Int_t n=0;
 if (!mode)
 {
  n=arr->GetEntries();
 }
 else
 {
  n=arr->GetSize();
 }
 return n;
}

NcSignal* NcAstrolab::GetSignal(Nc3Vector& r,TString frame,TString mode,NcTimestamp* ts,Int_t jref,Int_t type)
{
 
 r.SetZero();
 
 if (frame!="equ" && frame!="gal" && frame!="ecl" && frame!="hor" && frame!="icr" && frame!="loc") return 0;
 
 if (frame=="equ" && mode!="M" && mode!="m" && mode!="T" && mode!="t" && mode!="B" && mode!="b" && mode!="J" && mode!="j") return 0;
 
 // For backward compatibility
 if (!jref)
 {
  jref=1;
  type=1;
 }
 
 NcSignal* sx=GetSignal(jref,type);
 
 if (!sx) return 0;
 
 if (!ts) ts=(NcTimestamp*)this;
 
 // Check on maximum time difference
 if (fMaxDt>0)
 {
  NcTimestamp* tx=sx->GetTimestamp();
  if (!tx) return 0;
  Double_t dt=tx->GetDifference(ts,"s",1);
  if (fabs(dt)>fMaxDt) return 0;
 }
 
 // Update coordinates for Solar system objects
 TString name=sx->GetName();
 SetSolarSystem(name,ts,type);
 
 Double_t vec[3];
 sx->GetPosition(vec,"sph","rad");
 Nc3Vector q;
 q.SetVector(vec,"sph","rad");
 
 if (frame=="icr")
 {
  r.Load(q);
  return sx;
 }
 
 // Convert from ICRS to equatorial J2000 coordinates
 if (!fBias) SetBmatrix();
 q=q.GetPrimed(&fB);
 
 if (frame=="equ" && mode!="J" && mode!="j")
 {
  // Precess to specified timestamp
  NcTimestamp ts1;
  ts1.SetEpoch(2000,"J");
  if (mode!="B" && mode!="b")
  {
   Precess(q,&ts1,ts);
  }
  else
  {
   NcTimestamp ts2;
   ts2.SetEpoch(1950,"B");
   Precess(q,&ts1,&ts2);
  }
 
  // Nutation correction if requested
  if (mode=="T" || mode=="t") Nutate(q,ts);
 }
 
 if (frame=="gal")
 {
  // Convert from equatorial J2000 to galactic
  if (fGal != 2) SetGmatrix("J");
  q=q.GetPrimed(&fG);
 }
 
 if (frame=="ecl")
 {
  // Precess to specified timestamp
  NcTimestamp ts1;
  ts1.SetEpoch(2000,"J");
  Precess(q,&ts1,ts);
 
  // Convert from equatorial to ecliptic coordinates
  SetEmatrix(ts);
  q=q.GetPrimed(&fE);
 }
 
 if (frame=="hor")
 {
  // Precess to specified timestamp
  NcTimestamp ts1;
  ts1.SetEpoch(2000,"J");
  Precess(q,&ts1,ts);
 
  // Nutation correction
  Nutate(q,ts);
 
  // Convert from equatorial to horizontal coordinates
  SetHmatrix(ts);
  q=q.GetPrimed(&fH);
 }
 
 if (frame=="loc")
 {
  // Get the signal in horizontal coordinates
  GetSignal(q,"hor",mode,ts,jref,type);
 
  // Convert from horizontal to local-frame coordinates
  q=q.GetPrimed(&fL);
 }
 
 r.Load(q);
 return sx;
}

void NcAstrolab::GeoToHeliocentric(Double_t& R,Double_t& B,Double_t& L,NcTimestamp* ts,TString Bu,TString Lu)
{
 
 if (!ts) ts=(NcTimestamp*)this;
 
 // Convert the angles into radians
 B=ConvertAngle(B,Bu,"rad");
 L=ConvertAngle(L,Lu,"rad");
 
 // The Carthesian Geocentric ecliptic coordinates of the object
 Double_t xg=R*cos(B)*cos(L);
 Double_t yg=R*cos(B)*sin(L);
 Double_t zg=R*sin(B);
 
 // Get the Heliocentric ecliptic coordinates of the Earth
 Double_t r0,b0,l0;
 ts->Almanac(0,0,0,0,"Earth*",&l0,&b0,&r0);
 
 l0=ConvertAngle(l0,"deg","rad");
 b0=ConvertAngle(b0,"deg","rad");
 
 Double_t x0=r0*cos(b0)*cos(l0);
 Double_t y0=r0*cos(b0)*sin(l0);
 Double_t z0=r0*sin(b0);
 
 // The Heliocentric Carthesian ecliptic coordinates of the object
 Double_t xh=xg+x0;
 Double_t yh=yg+y0;
 Double_t zh=zg+z0;
 
 // Convert to Heliocentric distance, latitude and longitude
 Double_t Rh=sqrt(xh*xh+yh*yh+zh*zh);
 Double_t Bh=atan2(zh,sqrt(xh*xh+yh*yh));
 Double_t Lh=atan2(yh,xh);
 
 Double_t twopi=2.*acos(-1.);
 while (Lh<0) { Lh+=twopi; }
 while (Lh>twopi) { Lh-=twopi; }
 
 // Return the Heliocentric values in the original units
 R=Rh;
 B=ConvertAngle(Bh,"rad",Bu);
 L=ConvertAngle(Lh,"rad",Lu);
}

void NcAstrolab::HelioToGeocentric(Double_t& R,Double_t& B,Double_t& L,NcTimestamp* ts,TString Bu,TString Lu)
{
 
 if (!ts) ts=(NcTimestamp*)this;
 
 // Convert the angles into radians
 B=ConvertAngle(B,Bu,"rad");
 L=ConvertAngle(L,Lu,"rad");
 
 // The Carthesian Heliocentric ecliptic coordinates of the object
 Double_t xh=R*cos(B)*cos(L);
 Double_t yh=R*cos(B)*sin(L);
 Double_t zh=R*sin(B);
 
 // Get the Heliocentric ecliptic coordinates of the Earth
 Double_t r0,b0,l0;
 ts->Almanac(0,0,0,0,"Earth*",&l0,&b0,&r0);
 
 l0=ConvertAngle(l0,"deg","rad");
 b0=ConvertAngle(b0,"deg","rad");
 
 Double_t x0=r0*cos(b0)*cos(l0);
 Double_t y0=r0*cos(b0)*sin(l0);
 Double_t z0=r0*sin(b0);
 
 // The Geocentric Carthesian ecliptic coordinates of the object
 Double_t xg=xh-x0;
 Double_t yg=yh-y0;
 Double_t zg=zh-z0;
 
 // Convert to Geocentric distance, latitude and longitude
 Double_t Rg=sqrt(xg*xg+yg*yg+zg*zg);
 Double_t Bg=atan2(zg,sqrt(xg*xg+yg*yg));
 Double_t Lg=atan2(yg,xg);
 
 Double_t twopi=2.*acos(-1.);
 while (Lg<0) { Lg+=twopi; }
 while (Lg>twopi) { Lg-=twopi; }
 
 // Return the Geocentric values in the original units
 R=Rg;
 B=ConvertAngle(Bg,"rad",Bu);
 L=ConvertAngle(Lg,"rad",Lu);
}

NcSignal* NcAstrolab::GetSignal(Double_t& d,Double_t& a,TString au,Double_t& b,TString bu,TString frame,NcTimestamp* ts,Int_t jref,TString mode,Int_t type)
{
 
 d=0;
 a=0;
 b=0;
 
 Nc3Vector r;
 NcSignal* sx=GetSignal(r,frame,mode,ts,jref,type);
 
 if (!sx) return 0;
 
 // Retrieve the requested (a,d) values in the correct format
 Double_t vec[3];
 r.GetVector(vec,"sph","deg");
 
 d=vec[0];
 if (d<=0) d=1;
 b=vec[1];
 a=vec[2];
 
 if (frame=="equ" || frame=="gal" || frame=="ecl" || frame=="icr")
 {
  b=90.-vec[1];
  while (b<-90.)
  {
   b+=90.;
  }
  while (b>90.)
  {
   b-=90.;
  }
 }
 
 if (frame=="hor")
 {
  a=180.-vec[2];
 }
 
 while (a<-360.)
 {
  a+=360.;
 }
 while (a>360.)
 {
  a-=360.;
 }
 
 // Interchange a and b to represent theta and phi, respectively, for local coordinates
 if (frame=="loc")
 {
  Double_t temp=a;
  a=b;
  b=temp;
 }
 
 // Convert coordinates to appropriate format
 a=ConvertAngle(a,"deg",au);
 b=ConvertAngle(b,"deg",bu);
 
 return sx;
}

NcSignal* NcAstrolab::GetSignal(Double_t& d,Double_t& a,TString au,Double_t& b,TString bu,TString frame,NcTimestamp* ts,TString name,TString mode,Int_t type)
{
 
 // Set c.q. update coordinates for Solar system objects
 SetSolarSystem(name,ts,type);
 
 NcSignal* sx=0;
 Int_t j=GetSignalIndex(name,type);
 if (j>=0) sx=GetSignal(d,a,au,b,bu,frame,ts,j,mode,type);
 return sx;
}

NcSignal* NcAstrolab::GetSignal(Double_t& d,Double_t& a,TString au,Double_t& b,TString bu,TString frame,TString s,Double_t e,Int_t jref,TString mode,Int_t type)
{
 
 d=0;
 a=0;
 b=0;
 
 if (s!="B" && s!="b" && s!="J" && s!="j") return 0;
 
 NcTimestamp tx;
 tx.SetEpoch(e,s);
 
 NcSignal* sx=GetSignal(d,a,au,b,bu,frame,&tx,jref,mode,type);
 return sx;
}

NcSignal* NcAstrolab::GetSignal(Double_t& d,Double_t& a,TString au,Double_t& b,TString bu,TString frame,TString s,Double_t e,TString name,TString mode,Int_t type)
{
 
 // Set c.q. update coordinates for Solar system objects
 NcTimestamp tx;
 tx.SetEpoch(e,s);
 SetSolarSystem(name,&tx,type);
 
 NcSignal* sx=0;
 Int_t j=GetSignalIndex(name,type);
 if (j>=0) sx=GetSignal(d,a,au,b,bu,frame,s,e,j,mode,type);
 return sx;
}

NcSignal* NcAstrolab::GetSignal(Int_t jref,Int_t type)
{
 
 if (jref<0) return 0;
 
 if (!jref) // For backward compatibility
 {
  jref=1;
  type=1;
 }
 
 if (!type && !fRefs) return 0;
 if (type && !fSigs) return 0;
 
 NcSignal* sx=0;
 if (type)
 {
  if (jref<=fSigs->GetSize()) sx=(NcSignal*)fSigs->At(jref-1);
 }
 else
 {
  if (jref<=fRefs->GetSize()) sx=(NcSignal*)fRefs->At(jref-1);
 }
 return sx;
}

NcSignal* NcAstrolab::GetSignal(TString name,Int_t type,NcTimestamp* ts)
{
 
 NcSignal* sx=0;
 Int_t j=GetSignalIndex(name,type);
 
 if (j==-1) // Set and store info for the requested Solar system object if not already stored
 {
  SetSolarSystem(name,ts,type);
  j=GetSignalIndex(name,type);
 }
 
 if (j>=0) sx=GetSignal(j,type);
 return sx;
}

Int_t NcAstrolab::RemoveRefSignal(Int_t j,Int_t compress)
{
 
 Int_t nrem=0;
 
 if (!fRefs) return 0;
 
 // Clearing of the complete storage
 if (!j)
 {
  nrem=fRefs->GetEntries();
  delete fRefs;
  fRefs=0;
  return nrem;
 }
 
 // Removing a specific reference signal
 if (j>0 && j<=fRefs->GetSize())
 {
  TObject* obj=fRefs->RemoveAt(j-1);
  if (obj)
  {
   delete obj;
   nrem++;
  }
 }
 
 // Compression of the storage array
 if (compress) fRefs->Compress();
 
 return nrem;
}

Int_t NcAstrolab::RemoveRefSignal(TString name,Int_t compress)
{
 
 Int_t nrem=0;
 
 Int_t j=GetSignalIndex(name);
 if (j>0) nrem=RemoveRefSignal(j,compress);
 
 return nrem;
}

Int_t NcAstrolab::RemoveSignal(Int_t j,Int_t type,Int_t compress)
{
 
 Int_t nrem=0;
 
 TObjArray* arr=fRefs;
 if (type) arr=fSigs;
 
 if (!arr) return nrem;
 
 // Clearing of the complete "type" storage
 if (!j)
 {
  nrem=arr->GetEntries();
  delete arr;
  if (type)
  {
   fSigs=0;
   fNen[1]=0;
  }
  else
  {
   fRefs=0;
   fNen[0]=0;
  }
  return nrem;
 }
 
 // Removing the specified signal
 if (j>0 && j<=arr->GetSize())
 {
  TObject* obj=arr->RemoveAt(j-1);
  if (obj)
  {
   delete obj;
   nrem++;
  }
 }
 
 // Compression of the storage array
 if (compress)
 {
  arr->Compress();
  Int_t n=arr->GetEntries();
  arr->Expand(n);
 }
 
 return nrem;
}

Int_t NcAstrolab::RemoveSignal(TString name,Int_t type,Int_t compress)
{
 
 Int_t nrem=0;
 
 if (name=="") return nrem;
 
 if (name=="*")
 {
  nrem=RemoveSignal(0,type,compress);
 }
 else
 {
  Int_t j=GetSignalIndex(name,type);
  if (j>0) nrem=RemoveSignal(j,type,compress);
 }
 
 return nrem;
}

Int_t NcAstrolab::RemoveSignals(TString name,Int_t type,Int_t compress)
{
 
 Int_t nrem=0;
 
 if (name=="") return 0;
 
 if (name=="*")
 {
  nrem=RemoveSignal(0,type,compress);
 }
 else
 {
  TObjArray* arr=fRefs;
  if (type) arr=fSigs;
 
  if (!arr) return 0;
 
  NcSignal* sx=0;
  TString namex="";
  Int_t nremx=0;
  for (Int_t j=1; j<=arr->GetSize(); j++)
  {
   sx=GetSignal(j,type);
   if (!sx) continue;
 
   namex=sx->GetName();
   if (!namex.Contains(name)) continue;
 
   nremx=RemoveSignal(j,type,0);
   if (nremx) nrem++;
  }
 
  // Compression of the storage array
  if (compress)
  {
   arr->Compress();
   Int_t n=arr->GetEntries();
   arr->Expand(n);
  }
 }
 
 return nrem;
}

Int_t NcAstrolab::GetSignalIndex(TString name,Int_t type)
{
 
 if (name=="") return -1;
 
 Int_t index=-1;
 
 TObjArray* arr=fRefs;
 if (type) arr=fSigs;
 
 if (!arr) return -1;
 
 for (Int_t i=0; i<arr->GetSize(); i++)
 {
  NcSignal* sx=(NcSignal*)arr->At(i);
  if (!sx) continue;
 
  if (name==sx->GetName())
  {
   index=i+1;
   break;
  }
 }
 
 return index;
}

Int_t NcAstrolab::GetSignalIndex(NcSignal* s,Int_t type)
{
 
 if (!s) return -1;
 
 Int_t index=-1;
 
 TObjArray* arr=fRefs;
 if (type) arr=fSigs;
 
 if (!arr) return -1;
 
 for (Int_t i=0; i<arr->GetSize(); i++)
 {
  NcSignal* sx=(NcSignal*)arr->At(i);
  if (!sx) continue;
 
  if (sx==s)
  {
   index=i+1;
   break;
  }
 }
 
 return index;
}

void NcAstrolab::PrintSignal(TString frame,TString mode,NcTimestamp* ts,Int_t ndig,Int_t jref,TString emode,Int_t type,Bool_t align)
{
 
 NcSignal* sx=GetSignal(jref,type);
 
 if (!sx) return;
 
 if (!ts) ts=sx->GetTimestamp();
 
 Nc3Vector r;
 GetSignal(r,frame,mode,ts,jref,type);
 
 // Local Hour Angle of the signal
 Double_t lha=GetHourAngle("A",ts,jref,type);
 TString slha="LAHA";
 if (mode=="M" || mode=="m")
 {
  lha=GetHourAngle("M",ts,jref,type);
  slha="LMHA";
 }
 else if ((mode=="B" || mode=="b" || mode=="J" || mode=="j") && emode=="M")
 {
  lha=GetHourAngle("M",ts,jref,type);
  slha="LMHA";
 }
 
 if (frame=="equ")
 {
  Double_t a,d;
  d=90.-r.GetX(2,"sph","deg");
  a=r.GetX(3,"sph","rad");
  if (mode=="B" || mode=="b") mode="B1950";
  if (mode=="J" || mode=="j") mode="J2000";
  cout << "Equatorial (" << mode.Data() <<") | a :";
  if (!align) {cout << " ";} PrintAngle(a,"rad","hms",ndig,align);
  if (!align) {cout << " ";} PrintAngle(a,"rad","deg",ndig,align);
  cout << " | b :";
  if (!align) {cout << " ";} PrintAngle(d,"deg","dms",ndig,align);
  if (!align) {cout << " ";} PrintAngle(d,"deg","deg",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 if (frame=="gal")
 {
  Double_t l,b;
  b=90.-r.GetX(2,"sph","deg");
  l=r.GetX(3,"sph","deg");
  cout << "Galactic | l :";
  if (!align) {cout << " ";} PrintAngle(l,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(l,"deg","dms",ndig,align);
  cout << " | b :";
  if (!align) {cout << " ";} PrintAngle(b,"deg","deg",ndig,align); 
  if (!align) {cout << " ";} PrintAngle(b,"deg","dms",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 if (frame=="icr")
 {
  Double_t l,b;
  b=90.-r.GetX(2,"sph","deg");
  l=r.GetX(3,"sph","deg");
  cout << "ICRS | l :";
  if (!align) {cout << " ";} PrintAngle(l,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(l,"deg","dms",ndig,align);
  cout << " | b :";
  if (!align) {cout << " ";} PrintAngle(b,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(b,"deg","dms",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 if (frame=="ecl")
 {
  Double_t l,b;
  b=90.-r.GetX(2,"sph","deg");
  l=r.GetX(3,"sph","deg");
  cout << "Geocentric ecliptic | l :";
  if (!align) {cout << " ";} PrintAngle(l,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(l,"deg","dms",ndig,align);
  cout << " | b :";
  if (!align) {cout << " ";} PrintAngle(b,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(b,"deg","dms",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 if (frame=="hor")
 {
  Double_t alt=90.-r.GetX(2,"sph","deg");
  Double_t azi=180.-r.GetX(3,"sph","deg");
  while (azi>360)
  {
   azi-=360.;
  }
  while (azi<0)
  {
   azi+=360.;
  }
  cout << "Horizontal | azi :";
  if (!align) {cout << " ";} PrintAngle(azi,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(azi,"deg","dms",ndig,align);
  cout << " | alt :";
  if (!align) {cout << " ";} PrintAngle(alt,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(alt,"deg","dms",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 if (frame=="loc")
 {
  Double_t theta=r.GetX(2,"sph","deg");
  Double_t phi=r.GetX(3,"sph","deg");
  cout << "Local-frame | phi :";
  if (!align) {cout << " ";} PrintAngle(phi,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(phi,"deg","dms",ndig,align);
  cout << " | theta :";
  if (!align) {cout << " ";} PrintAngle(theta,"deg","deg",ndig,align);
  if (!align) {cout << " ";} PrintAngle(theta,"deg","dms",ndig,align);
  cout << " | " << slha.Data() << " : ";
  PrintAngle(lha,"deg","hms",ndig,align);
  cout << " "; PrintAngle(lha,"deg","deg",ndig,align);
 }
 
 cout << " |";
 
 TString name=sx->GetName();
 if (name != "") cout << " " << name.Data();
}

void NcAstrolab::PrintSignal(TString frame,TString mode,NcTimestamp* ts,Int_t ndig,TString name,TString emode,Int_t type,Bool_t align)
{
 
 // Set c.q. update coordinates for Solar system objects
 SetSolarSystem(name,ts,type);
 
 Int_t j=GetSignalIndex(name,type);
 if (j>=0) PrintSignal(frame,mode,ts,ndig,j,emode,type,align);
}

void NcAstrolab::ListSignals(TString frame,TString mode,Int_t ndig,TString emode,Int_t nmax,Int_t j,Int_t type,NcTimestamp* ts,TString name)
{
 
 Int_t iprint=0;
 Int_t width=0; // Width for printing of the index
 if (nmax>0) width=log10(nmax);
 if (nmax<0)
 {
  Int_t maxref=0;
  if (fRefs) maxref=fRefs->GetSize();
  Int_t maxsig=0;
  if (fSigs) maxsig=fSigs->GetSize();
  Int_t maxj=maxref;
  if (maxsig>maxj) maxj=maxsig;
  if (maxj>0) width=log10(maxj);
 }
 width++;
 
 NcSignal* sx=0;
 NcTimestamp* tx=0;
 
 Int_t dform=1;
 if (mode=="T" || mode=="t") dform=-1;
 if ((mode=="B" || mode=="b" || mode=="J" || mode=="j") && emode=="T") dform=-1;
 
 if (j>0) sx=GetSignal(j,1);
 if (sx)
 {
  tx=sx->GetTimestamp();
  if (!tx) tx=ts;
  if (!tx) tx=(NcTimestamp*)this;
  printf(" *%-s::ListSignals* Name : %-s Title : %-s \n",ClassName(),GetName(),GetTitle());
  if (fTscmode!=2)
  {
   cout << " Timestamp of the measurement stored at index=" << j;
  }
  else
  {
   cout << " *Scrambled* timestamp of the measurement stored at index=" << j;
  }
  cout << " (Lab time offset w.r.t. UT : "; PrintTime(fToffset,12); cout << ")" << endl;
  tx->Date(dform,fToffset);
  tx->Date(4);
  cout << " Corresponding location of this measurement" << endl;
  cout << " "; PrintSignal(frame,mode,tx,ndig,j,emode,1); cout << endl;
  iprint=1;
 }
 
 TObjArray* arr=0;
 Int_t nstored=0;
 Int_t jlist=0;
 Int_t test=type;
 while (test<2)
 {
  if (test==0)
  {
   type=0;
   arr=fRefs;
   test=999;
  }
  if (test==1)
  {
   type=1;
   arr=fSigs;
   test=999;
  }
  if (test<0)
  {
   type=0;
   arr=fRefs;
   test=1;
  }
  
  if (!arr) continue;
 
  nstored=arr->GetEntries();
  jlist=0;
  TString namex="";
  for (Int_t i=1; i<=arr->GetSize(); i++)
  {
   sx=GetSignal(i,type);
   if (!sx) continue;
 
   jlist++;
   if (nmax>=0 && jlist>nmax) break;
 
   // Check for the name pattern
   namex=sx->GetName();
   if (name!="*" && !namex.Contains(name)) continue;
 
   if (!iprint)
   {
    printf(" *%-s::ListSignals* Name : %-s Title : %-s \n",ClassName(),GetName(),GetTitle());
    if (j==0) tx=ts;
    if (tx)
    {
     cout << " User provided timestamp (Lab time offset w.r.t. UT : "; PrintTime(fToffset,12); cout << ")";
     cout << endl;
     tx->Date(dform,fToffset);
     tx->Date(4);
    }
    else
    {
     tx=(NcTimestamp*)this;
     if (j>=0)
     {
      cout << " Current timestamp of the laboratory (Lab time offset w.r.t. UT : "; PrintTime(fToffset,12); cout << ")";
      cout << endl;
      tx->Date(dform,fToffset);
      tx->Date(4);
     }
    }
    iprint=1;
   }
   if (iprint==1)
   {
    if (nmax<0 || nmax>=nstored)
    {
     if (!type)
     {
      if (j>=0)
      {
       cout << " === All stored reference signals according to the above timestamp ===" << endl;
      }
      else
      {
       cout << " === All stored reference signals according to their actual recorded timestamp ===" << endl;
      }
     }
     else
     {
      if (fTscmode!=2)
      {
       cout << " === All stored measurements according to their actual observation timestamp ===" << endl;
      }
      else
      {
       cout << " === All stored measurements according to their *scrambled* observation timestamp ===" << endl;
       cout << " === Time scrambling was performed by adding dt from the interval [dtmin,dtmax] to their actual timestamp" << endl;
       cout << " === dtmin : " << fTscmin << " dtmax : " << fTscmax << " sec.";
       if (fTscfunc)
       {
        cout << " Randomising TF1 function " << fTscfunc->GetName() << " was used." << endl;
       }
       else
       {
        cout << " Uniform randomisation was used." << endl;
       }
      }
     } 
    }
    else
    {
     if (!type)
     {
      if (j>=0)
      {
       cout << " === The first " << nmax << " stored reference signals according to the above timestamp ===" << endl;
      }
      else
      {
       cout << " === The first " << nmax << " stored reference signals according to their actual recorded timestamp ===" << endl;
      }
     }
     else
     {
      if (fTscmode!=2)
      {
       cout << " === The first " << nmax << " stored measurements according to their actual observation timestamp ===" << endl;
      }
      else
      {
       cout << " === The first " << nmax << " stored measurements according to their *scrambled* observation timestamp ===" << endl;
       cout << " === Time scrambling was performed by adding dt from the interval [dtmin,dtmax] to their actual timestamp" << endl;
       cout << " === dtmin : " << fTscmin << " dtmax : " << fTscmax << " sec.";
       if (fTscfunc)
       {
        cout << " Randomising TF1 function " << fTscfunc->GetName() << " was used." << endl;
       }
       else
       {
        cout << " Uniform randomisation was used." << endl;
       }
      }
     }
    }
    iprint=2;
   }
   if (type==1 || (!type && j<0)) tx=0;
   printf(" Index : %*d ",width,i); PrintSignal(frame,mode,tx,ndig,i,emode,type,kTRUE); printf("\n");
  }
  iprint=1;
 }
}

void NcAstrolab::Precess(Nc3Vector& r,NcTimestamp* ts1,NcTimestamp* ts2)
{
 
 // Convert back to J2000 values
 Nc3Vector r0;
 SetPmatrix(ts1);
 r0=r.GetUnprimed(&fP);
 
 // Precess to the specified timestamp
 if (!ts2) ts2=(NcTimestamp*)this;
 SetPmatrix(ts2);
 r=r0.GetPrimed(&fP);
}

void NcAstrolab::Nutate(Nc3Vector& r,NcTimestamp* ts)
{
 
 // Nutation correction for the specified timestamp
 if (!ts) ts=(NcTimestamp*)this;
 SetNmatrix(ts);
 r=r.GetPrimed(&fN);
}

void NcAstrolab::SetBmatrix()
{
 
 Double_t pi=acos(-1.);
 
 // Parameters in mas
 Double_t a=-14.6;
 Double_t x=-16.6170;
 Double_t e=-6.8192;
 
 // Convert to radians
 a*=pi/(180.*3600.*1000.);
 x*=pi/(180.*3600.*1000.);
 e*=pi/(180.*3600.*1000.);
 
 Double_t mat[9];
 mat[0]=1.-0.5*(a*a+x*x);
 mat[1]=a;
 mat[2]=-x;
 mat[3]=-a-e*x;
 mat[4]=1.-0.5*(a*a+e*e);
 mat[5]=-e;
 mat[6]=x-e*a;
 mat[7]=e+x*a;
 mat[8]=1.-0.5*(e*e+x*x);
 
 fB.SetMatrix(mat);
 fBias=1;
}

void NcAstrolab::SetPmatrix(NcTimestamp* ts)
{
 
 Double_t mat[9]={0,0,0,0,0,0,0,0,0};
 if (!ts)
 {
  fP.SetMatrix(mat);
  return;
 }
 
 Double_t pi=acos(-1.);
 
 Double_t t=(ts->GetJD()-2451545.0)/36525.; // Julian centuries since J2000.0
 
 // Parameters for the precession matrix in arcseconds
 Double_t eps0=84381.406; // Mean ecliptic obliquity at J2000.0
 Double_t psi=5038.481507*t-1.0790069*pow(t,2)-0.00114045*pow(t,3)+0.000132851*pow(t,4)
                -0.0000000951*pow(t,4);
 Double_t om=eps0-0.025754*t+0.0512623*pow(t,2)-0.00772503*pow(t,3)-0.000000467*pow(t,4)
                 +0.0000003337*pow(t,5);
 Double_t chi=10.556403*t-2.3814292*pow(t,2)-0.00121197*pow(t,3)+0.000170663*pow(t,4)
              -0.0000000560*pow(t,5);
 
 // Convert to radians
 eps0*=pi/(180.*3600.);
 psi*=pi/(180.*3600.);
 om*=pi/(180.*3600.);
 chi*=pi/(180.*3600.);
 
 Double_t s1=sin(eps0);
 Double_t s2=sin(-psi);
 Double_t s3=sin(-om);
 Double_t s4=sin(chi);
 Double_t c1=cos(eps0);
 Double_t c2=cos(-psi);
 Double_t c3=cos(-om);
 Double_t c4=cos(chi);
 
 mat[0]=c4*c2-s2*s4*c3;
 mat[1]=c4*s2*c1+s4*c3*c2*c1-s1*s4*s3;
 mat[2]=c4*s2*s1+s4*c3*c2*s1+c1*s4*s3;
 mat[3]=-s4*c2-s2*c4*c3;
 mat[4]=-s4*s2*c1+c4*c3*c2*c1-s1*c4*s3;
 mat[5]=-s4*s2*s1+c4*c3*c2*s1+c1*c4*s3;
 mat[6]=s2*s3;
 mat[7]=-s3*c2*c1-s1*c3;
 mat[8]=-s3*c2*s1+c3*c1;
 
 fP.SetMatrix(mat);
}

void NcAstrolab::SetNmatrix(NcTimestamp* ts)
{
 
 Double_t mat[9]={0,0,0,0,0,0,0,0,0};
 if (!ts)
 {
  fN.SetMatrix(mat);
  return;
 }
 
 Double_t pi=acos(-1.);
 
 Double_t dpsi,deps,eps;
 ts->Almanac(&dpsi,&deps,&eps);
 
 // Convert to radians
 dpsi*=pi/(180.*3600.);
 deps*=pi/(180.*3600.);
 eps*=pi/(180.*3600.);
 
 Double_t s1=sin(eps);
 Double_t s2=sin(-dpsi);
 Double_t s3=sin(-(eps+deps));
 Double_t c1=cos(eps);
 Double_t c2=cos(-dpsi);
 Double_t c3=cos(-(eps+deps));
 
 mat[0]=c2;
 mat[1]=s2*c1;
 mat[2]=s2*s1;
 mat[3]=-s2*c3;
 mat[4]=c3*c2*c1-s1*s3;
 mat[5]=c3*c2*s1+c1*s3;
 mat[6]=s2*s3;
 mat[7]=-s3*c2*c1-s1*c3;
 mat[8]=-s3*c2*s1+c3*c1;
 
 fN.SetMatrix(mat);
}

void NcAstrolab::SetGmatrix(TString mode)
{
 
 Nc3Vector x; // The Galactic x-axis in the equatorial frame
 Nc3Vector y; // The Galactic y-axis in the equatorial frame
 Nc3Vector z; // The Galactic z-axis in the equatorial frame
 
 Double_t a,d;
 Double_t vec[3]={1,0,0};
 
 fGal=1; // Set flag to indicate B1950 matrix values
 
 // B1950 equatorial coordinates of the North Galactic Pole (NGP)
 a=124900.;
 d=272400.;
 a=ConvertAngle(a,"hms","deg");
 d=ConvertAngle(d,"dms","deg");
 vec[1]=90.-d;
 vec[2]=a;
 z.SetVector(vec,"sph","deg");
 
 // B1950 equatorial coordinates of the Galactic l=b=0 point
 a=174224.;
 d=-285500.;
 a=ConvertAngle(a,"hms","deg");
 d=ConvertAngle(d,"dms","deg");
 vec[1]=90.-d;
 vec[2]=a;
 x.SetVector(vec,"sph","deg");
 
 // Precess to the corresponding J2000 values if requested
 if (mode=="J")
 {
  fGal=2; // Set flag to indicate J2000 matrix values
  NcTimestamp t1;
  t1.SetEpoch(1950,"B");
  NcTimestamp t2;
  t2.SetEpoch(2000,"J");
  Precess(z,&t1,&t2);
  Precess(x,&t1,&t2);
 }
 
 // The Galactic y-axis is determined for the right handed frame
 y=z.Cross(x);
 
 fG.SetAngles(x.GetX(2,"sph","deg"),x.GetX(3,"sph","deg"),
              y.GetX(2,"sph","deg"),y.GetX(3,"sph","deg"),
              z.GetX(2,"sph","deg"),z.GetX(3,"sph","deg"));
}

void NcAstrolab::SetEmatrix(NcTimestamp* ts)
{
 
 Double_t dpsi,deps,eps;
 ts->Almanac(&dpsi,&deps,&eps);
 
 // Convert to degrees
 eps/=3600.;
 
 // Positions of the ecliptic axes w.r.t. the equatorial ones
 // at the moment of the specified timestamp 
 Double_t theta1=90; // Ecliptic x-axis
 Double_t phi1=0;
 Double_t theta2=90.-eps; //Ecliptic y-axis
 Double_t phi2=90;
 Double_t theta3=eps; // Ecliptic z-axis
 Double_t phi3=270;
 
 fE.SetAngles(theta1,phi1,theta2,phi2,theta3,phi3);
}

void NcAstrolab::SetHmatrix(NcTimestamp* ts)
{
 
 Nc3Vector x; // The (South pointing) horizontal x-axis in the equatorial frame
 Nc3Vector y; // The (East pointing) horizontal y-axis in the equatorial frame
 Nc3Vector z; // The (Zenith pointing) horizontal z-axis in the equatorial frame
 
 Double_t l,b;
 GetLabPosition(l,b,"deg");
 
 Double_t a;
 Double_t vec[3]={1,0,0};
 
 // Equatorial coordinates of the horizontal z-axis
 // at the moment of the specified timestamp 
 a=ts->GetLAST(fToffset);
 a*=15.; // Convert fractional hours to degrees 
 vec[1]=90.-b;
 vec[2]=a;
 z.SetVector(vec,"sph","deg");
 
 // Equatorial coordinates of the horizontal x-axis
 // at the moment of the specified timestamp 
 vec[1]=180.-b;
 vec[2]=a;
 x.SetVector(vec,"sph","deg");
 
 // The horizontal y-axis is determined for the right handed frame
 y=z.Cross(x);
 
 fH.SetAngles(x.GetX(2,"sph","deg"),x.GetX(3,"sph","deg"),
              y.GetX(2,"sph","deg"),y.GetX(3,"sph","deg"),
              z.GetX(2,"sph","deg"),z.GetX(3,"sph","deg"));
}

void NcAstrolab::SetLocalFrame(Double_t t1,Double_t p1,Double_t t2,Double_t p2,Double_t t3,Double_t p3)
{
 
 // Set the matrix for the conversion of our reference frame coordinates
 // into the local-frame ones.
 
 fL.SetAngles(t1,p1,t2,p2,t3,p3);
 
 // Store the local user frame axes orientations w.r.t. the standard local Horizon (zen,azi) frame
 fAxes[0]=t1;
 fAxes[1]=p1;
 fAxes[2]=t2;
 fAxes[3]=p2;
 fAxes[4]=t3;
 fAxes[5]=p3;
}

void NcAstrolab::GetLocalFrame(Float_t* arr)
{
 
 arr[0]=fAxes[0];
 arr[1]=fAxes[1];
 arr[2]=fAxes[2];
 arr[3]=fAxes[3];
 arr[4]=fAxes[4];
 arr[5]=fAxes[5];
}

Double_t NcAstrolab::ConvertAngle(Double_t a,TString in,TString out) const
{
 
 if (in==out) return a;
 
 // Convert input to its absolute value in (fractional) degrees. 
 Double_t pi=acos(-1.);
 Double_t epsilon=1.e-12; // Accuracy in (arc)seconds
 Int_t word=0,ddd=0,hh=0,mm=0,ss=0;
 Double_t s=0;
 
 Double_t b=fabs(a);
 
 if (in=="rad") b*=180./pi;
 
 if (in=="hrs") b*=15.;
 
 if (in=="dms")
 {
  word=Int_t(b);
  ddd=word/10000;
  word=word%10000;
  mm=word/100;
  ss=word%100;
  s=b-Double_t(ddd*10000+mm*100+ss);
  b=Double_t(ddd)+Double_t(mm)/60.+(Double_t(ss)+s)/3600.;
 }
 
 if (in=="hms")
 {
  word=Int_t(b);
  hh=word/10000;
  word=word%10000;
  mm=word/100;
  ss=word%100;
  s=b-Double_t(hh*10000+mm*100+ss);
  b=15.*(Double_t(hh)+Double_t(mm)/60.+(Double_t(ss)+s)/3600.);
 }
 
 while (b>360)
 {
  b-=360.;
 }
 
 if (out=="rad") b*=pi/180.;
 
 if (out=="hrs") b/=15.;
 
 if (out=="dms")
 {
  ddd=Int_t(b);
  b=b-Double_t(ddd);
  b*=60.;
  mm=Int_t(b);
  b=b-Double_t(mm);
  b*=60.;
  ss=Int_t(b);
  s=b-Double_t(ss);
  if (s>(1.-epsilon))
  {
   s=0.;
   ss++;
  }
  while (ss>=60)
  {
   ss-=60;
   mm++;
  }
  while (mm>=60)
  {
   mm-=60;
   ddd++;
  }
  while (ddd>=360)
  {
   ddd-=360;
  }
  b=Double_t(10000*ddd+100*mm+ss)+s;
 }
 
 if (out=="hms")
 {
  b/=15.;
  hh=Int_t(b);
  b=b-Double_t(hh);
  b*=60.;
  mm=Int_t(b);
  b=b-Double_t(mm);
  b*=60.;
  ss=Int_t(b);
  s=b-Double_t(ss);
  if (s>(1.-epsilon))
  {
   s=0.;
   ss++;
  }
  while (ss>=60)
  {
   ss-=60;
   mm++;
  }
  while (mm>=60)
  {
   mm-=60;
   hh++;
  }
  while (hh>=24)
  {
   hh-=24;
  }
  b=Double_t(10000*hh+100*mm+ss)+s;
 }
 
 if (a<0) b=-b;
 
 return b;
}

Double_t NcAstrolab::GetSolidAngle(Double_t thetamin,Double_t thetamax,TString tu,Double_t phimin,Double_t phimax,TString pu) const
{
 
 Double_t omega=0;
 
 Double_t th1=ConvertAngle(thetamin,tu,"rad");
 Double_t th2=ConvertAngle(thetamax,tu,"rad");
 Double_t ph1=ConvertAngle(phimin,pu,"rad");
 Double_t ph2=ConvertAngle(phimax,pu,"rad");
 
 omega=(ph2-ph1)*(cos(th1)-cos(th2));
 if (omega<0) omega=-omega;
 
 return omega;
}

Double_t NcAstrolab::GetHourAngle(TString mode,NcTimestamp* ts,Int_t jref,Int_t type)
{
 
 if (!ts) ts=(NcTimestamp*)this;
 
 // Get corrected right ascension and declination for the specified timestamp.
 Double_t d,a,b;
 if (mode=="M" || mode=="m") GetSignal(d,a,"deg",b,"deg","equ",ts,jref,"M",type);
 if (mode=="A" || mode=="a") GetSignal(d,a,"deg",b,"deg","equ",ts,jref,"T",type);
 
 a/=15.; // Convert a to fractional hours
 Double_t ha=0;
 if (mode=="M" || mode=="m") ha=ts->GetLMST(fToffset)-a;
 if (mode=="A" || mode=="a") ha=ts->GetLAST(fToffset)-a;
 ha*=15.; // Convert to (fractional) degrees
 
 // Project to the interval [-180,180]
 while (ha<-180)
 {
  ha+=360.;
 }
 while (ha>180)
 {
  ha-=360.;
 }
 
 return ha;
}

void NcAstrolab::SetLT(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns,Int_t ps)
{
 
 SetLT(fToffset,y,m,d,hh,mm,ss,ns,ps);
}

void NcAstrolab::SetLT(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Double_t s)
{
 
 SetLT(fToffset,y,m,d,hh,mm,s);
}

void NcAstrolab::SetLT(Int_t y,Int_t m,Int_t d,TString time)
{
 
 SetLT(fToffset,y,m,d,time);
}

void NcAstrolab::SetLT(TString date,TString time,Int_t mode)
{
 
 SetLT(fToffset,date,time,mode);
}

void NcAstrolab::SetLT(Int_t y,Int_t d,Int_t s,Int_t ns,Int_t ps)
{
 
 SetLT(fToffset,y,d,s,ns,ps);
}

Double_t NcAstrolab::GetDifference(Int_t j,TString au,Double_t& dt,TString tu,Int_t mode,Int_t* ia,Int_t* it)
{
 
 Double_t da=999;
 dt=1.e30;
 
 if (ia) *ia=0;
 if (it) *it=0;
 
 if (j<0) return da;
 
 NcDevice matches;
 Int_t nhits=0;
 NcSignal* sx=0;
 if (j) // Space and time difference w.r.t. a specific reference signal
 {
  MatchSignals(matches,da,au,dt,tu,mode,j,j,0,1,1,1);
  nhits=matches.GetNhits();
  if (nhits)
  {
   da=matches.GetSignal(1);
   dt=matches.GetSignal(2);
   if (ia) *ia=j;
   if (it) *it=j;
  }
 }
 else // Minimal space and time difference encountered over all reference signals
 {
  MatchSignals(matches,da,au,dt,tu,mode,1,0,0,1,1,1);
  nhits=matches.GetNhits();
  if (nhits)
  {
   da=matches.GetSignal(1);
   dt=matches.GetSignal(2);
   if (ia)
   {
    Int_t ipsi=matches.GetSignal("ipsi");
    sx=matches.GetHit(ipsi);
    if (sx) *ia=sx->GetSignal("index1");
   }
   if (it)
   {
    Int_t idt=matches.GetSignal("idt");
    sx=matches.GetHit(idt);
    if (sx) *it=sx->GetSignal("index1");
   }
  }
 }
 return da;
}

Double_t NcAstrolab::GetSeparation(TString name1,TString name2,TString au,Double_t* dt,TString tu,Int_t mode,Double_t* diftheta,Double_t* difphi)
{
 
 // Obtain the storage indices for the requested signals
 Int_t i=GetSignalIndex(name1,1); // Search for "name1" among the measurement signals
 Int_t j=GetSignalIndex(name2,1); // Search for "name2" among the measurement signals
 
 if (i>0) // Set to negative value to indicate measurement entry
 {
  i=-i;
 }
 else // Search for "name1" among the reference signals
 {
  // In case a Solar system body was specified, store c.q. update it as a reference object.
  SetSolarSystem(name1,0,0);
  i=GetSignalIndex(name1,0);
  if (i<0) i=0;
 }
 
 if (j>0) // Set to negative value to indicate measurement entry
 {
  j=-j;
 }
 else // Search for "name2" among the reference signals
 {
  // In case a Solar system body was specified, store c.q. update it as a reference object.
  SetSolarSystem(name2,0,0);
  j=GetSignalIndex(name2,0);
  if (j<0) j=0;
 }
 
 // Retrieve the requested data via the internal GetSeparation() memberfunction
 Double_t dtx;
 Double_t da=GetSeparation(i,j,au,dtx,tu,mode,0,diftheta,difphi);
 
Double_t dthetax,dphix;
da=GetSeparation(i,j,au,dtx,tu,mode,0,&dthetax,&dphix);
printf(" i=%-i j=%-i da=%-g dt=%-g %-s dtheta=%-g dphi=%-g %-s \n",i,j,da,dtx,tu.Data(),dthetax,dphix,au.Data());
 
 if (dt) *dt=dtx;
 return da;
}

Double_t NcAstrolab::GetSeparation(Int_t i,Int_t j,TString au,Double_t& dt,TString tu,Int_t mode,Int_t bkgpatch,Double_t* diftheta,Double_t* difphi)
{
 
 Double_t dang=-999;
 dt=1.e30;
 if (diftheta) *diftheta=-999;
 if (difphi) *difphi=-999;
 
 if (!i || !j) return dang;
 if ((i>0 || j>0) && !fRefs) return dang;
 if ((i<0 || j<0) && !fSigs) return dang;
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // with identical measurements and reference signals without explicit initialisation
 // of the randomiser by the user at the start of the analysis.
 if (!fRan && (fRscmode>0 || fTscmode>0)) fRan=new NcRandom(-1);
 
 Int_t itype=0;
 if (i<0)
 {
  itype=1;
  i=abs(i);
 }
 
 Int_t jtype=0;
 if (j<0)
 {
  jtype=1;
  j=abs(j);
 }
 
 Nc3Vector ri; // Position of the i-th signal
 Nc3Vector rj; // Position of the j-th signal
 NcSignal* si=0; // Link to the stored i-th signal
 NcSignal* sj=0; // Link to the stored j-th signal
 NcTimestamp* ti=0; // Link to the timestamp of the i-th signal
 NcTimestamp* tj=0; // Link to the timestamp of the j-th signal
 
 si=GetSignal(i,itype);
 sj=GetSignal(j,jtype);
 if (!si || !sj) return dang;
 
 ti=si->GetTimestamp();
 tj=sj->GetTimestamp();
 if (!ti || !tj) return dang;
 
 Int_t reftype=0;
 Int_t evttype=0;
 Int_t idxref=0;
 Int_t idxevt=0;
 NcSignal* sxref=0; // Link to the stored reference signal
 NcTimestamp* txref=0; // Link to the timestamp of the reference signal
 NcTimestamp* txevt=0; // Link to the timestamp of the measurement signal
 Nc3Vector rxref; // Position of the reference signal
 Nc3Vector rxevt; // Position of the measurement signal
 
 if (itype==jtype) // Self correlations
 {
  reftype=itype;
  idxref=i;
  sxref=si;
  txref=ti;
  evttype=jtype;
  idxevt=j;
  txevt=tj;
 }
 else // Correlations between sources and measurements
 {
  if (itype)
  {
   evttype=itype;
   idxevt=i;
   txevt=ti;
   reftype=jtype;
   idxref=j;
   sxref=sj;
   txref=tj;
  }
  else
  {
   reftype=itype;
   idxref=i;
   sxref=si;
   txref=ti;
   evttype=jtype;
   idxevt=j;
   txevt=tj;
  }
 }
 
 // Update the location and timestamp in case of a Solar system reference object
 TString name=sxref->GetName();
 if (SetSolarSystem(name,txevt,reftype)) txref=sxref->GetTimestamp();
 
 // Local variables to act on requested scrambling
 Int_t Tscmode=fTscmode;
 Int_t Rscmode=fRscmode;
 
 // Create scrambled background patch data even when also the on-source data are scrambled 
 if (bkgpatch)
 {
  Tscmode=-abs(fTscmode);
  Rscmode=-abs(fRscmode);
 }
 
 // Apply time scrambling of the date/time of the observation if requested
 NcTimestamp txtmp(*txevt);
 Double_t trndm=0;
 if (Tscmode==1 || Tscmode==3 || (Tscmode<0 && bkgpatch))
 {
  if (!fTscfunc)
  {
   trndm=fRan->Uniform(fTscmin,fTscmax);
  }
  else
  {
   trndm=fTscfunc->GetRandom(fTscmin,fTscmax);
  }
  // Creating a fake scrambled timestamp
  if (Tscmode==3 || (abs(Tscmode)>1 && bkgpatch)) txtmp.AddSec(trndm);
 }
 
 // Obtain the (scrambled) time difference
 if (Tscmode==1 || (Tscmode==-1 && bkgpatch)) // Only provide a random time difference
 {
  if (tu=="d")
  {
   trndm/=double(24*3600);
  }
  if (tu=="ns")
  {
   trndm*=1.e9;
   trndm*=1.e9;
  }
  if (tu=="ps")
  {
   trndm*=1.e12;
   trndm*=1.e12;
  }
  dt=trndm;
 }
 else // Determine the time difference w.r.t. the fake timestamp of the measurement
 {
  dt=txref->GetDifference(&txtmp,tu,mode);
 }
 
 // Update the location of Solar system objects if needed
 name=sxref->GetName();
 SetSolarSystem(name,&txtmp,reftype);
 
 // Get the original measurement position and (time modified) reference position in local coordinates
 GetSignal(rxevt,"loc","T",txevt,idxevt,evttype);
 GetSignal(rxref,"loc","T",&txtmp,idxref,reftype);
 
 // Apply position scrambling of the measurement if requested
 Double_t pi=acos(-1.);
 Float_t cosmin=0;
 Float_t cosmax=0;
 Double_t cosang=0;
 Double_t vec[3];
 Double_t dd=0;
 Double_t dtheta=0;
 Double_t dphi=0;
 
 if (Rscmode==1 || (Rscmode==-1 && bkgpatch)) // Only provide a random angular separation
 {
  if (!fDscfunc)
  {
   cosmin=cos(fDscmin*pi/180.);
   cosmax=cos(fDscmax*pi/180.);
   if (cosmin>cosmax)
   {
    Float_t temp=cosmin;
    cosmin=cosmax;
    cosmax=temp;
   }
   cosang=fRan->Uniform(cosmin,cosmax);
   dang=acos(cosang);
   if (au=="deg") dang*=180./pi;
  }
  else
  {
   dang=fDscfunc->GetRandom(fDscmin,fDscmax);
   if (au=="rad") dang*=pi/180.;
  }
 }
 else // Create a fake local position for the measurement
 {
  if (Rscmode==3 || (abs(Rscmode)>1 && bkgpatch))
  {
   rxevt.GetVector(vec,"sph","deg"); 
 
   // Allow specific offset studies
   if (fDscmin==fDscmax) dd=fDscmin;
   if (fThetascmin==fThetascmax) dtheta=fThetascmin;
   if (fPhiscmin==fPhiscmax) dphi=fPhiscmin;
 
   // Go for randomly scrambled values
   if (fDscfunc)
   {
    if (fDscmax>fDscmin)
    {
     dd=fDscfunc->GetRandom(fDscmin,fDscmax);
    }
   }
   else 
   {
    if (fDscmax>fDscmin) dd=fRan->Uniform(fDscmin,fDscmax);
   }
 
   if (fThetascfunc)
   {
    if (fThetascmax>fThetascmin)
    {
     dtheta=fThetascfunc->GetRandom(fThetascmin,fThetascmax);
    }
   }
   else if (fThetascmax>fThetascmin)
   {
    cosmin=cos(fThetascmin*pi/180.);
    cosmax=cos(fThetascmax*pi/180.);
    if (cosmin>cosmax)
    {
     Float_t temp=cosmin;
     cosmin=cosmax;
     cosmax=temp;
    }
    cosang=fRan->Uniform(cosmin,cosmax);
    dtheta=acos(cosang)*180./pi;
   }
 
   if (fPhiscfunc)
   {
    if (fPhiscmax>fPhiscmin)
    {
     dphi=fPhiscfunc->GetRandom(fPhiscmin,fPhiscmax);
    }
   }
   else
   {
    if (fPhiscmax>fPhiscmin) dphi=fRan->Uniform(fPhiscmin,fPhiscmax);
   }
 
   vec[0]+=dd;
   if (vec[0]<=0) vec[0]=1e-20; // Keep a physical situation
   vec[1]+=dtheta;
   vec[2]+=dphi;
   rxevt.SetVector(vec,"sph","deg");
  }
  
  dang=rxref.GetOpeningAngle(rxevt,au);
 }
 
 // Determine the difference in local theta and phi
 Double_t refvec[3];
 rxevt.GetVector(vec,"sph",au);
 rxref.GetVector(refvec,"sph",au);
 dtheta=vec[1]-refvec[1];
 dphi=vec[2]-refvec[2];
 if (diftheta) *diftheta=dtheta;
 if (difphi) *difphi=dphi;
 
 return dang;
}

Double_t NcAstrolab::GetDifference(TString name,TString au,Double_t& dt,TString tu,Int_t mode)
{
 
 Double_t dang=999;
 dt=1.e30;
 
 Int_t j=GetSignalIndex(name);
 
 if (j==-1) // Set and store info for the requested Solar system object if not already stored
 {
  SetSolarSystem(name,0);
  j=GetSignalIndex(name);
 }
 
 if (j>0) dang=GetDifference(j,au,dt,tu,mode);
 return dang;
}

TArrayI* NcAstrolab::MatchRefSignal(Double_t da,TString au,Double_t dt,TString tu,Int_t mode)
{
 
 if (!fSigs || !fRefs) return 0;
 
 NcDevice matches;
 MatchSignals(matches,da,au,dt,tu,mode,1,0,0,1,1,1); // Perform the obsolete MatchRefSignal() action
 
 Int_t nhits=matches.GetNhits();
 if (!nhits) return 0;
 
 if (fIndices) delete fIndices;
 fIndices=new TArrayI(nhits);
 
 Int_t index=0;
 NcSignal* sx=0;
 Int_t jfill=0;
 for (Int_t i=1; i<=nhits; i++)
 {
  sx=matches.GetHit(i);
 
  if(!sx) continue;
 
  index=sx->GetSignal("index1");
  fIndices->AddAt(index,jfill);
  jfill++;
 }
 
 fIndices->Set(jfill);
 
 if (!jfill) return 0; // No match found
 
 return fIndices;
}

void NcAstrolab::MatchSignals(NcDevice& matches,Double_t da,TString au,Double_t dt,TString tu,Int_t mode,Int_t i1,Int_t i2,Int_t itype,Int_t j1,Int_t j2,Int_t jtype)
{
 
 // Initialize the Device/Hit structure to contain the correlation info 
 matches.Reset(1);
 matches.SetHitCopy(1);
 
 TString name="Matches";
 TString title="Space and time matchings of NcAstrolab stored signals";
 matches.SetNameTitle(name.Data(),title.Data());
 TString tux=tu;
 if (tu=="d") tux="days";
 if (tu=="s") tux="sec";
 TString namedamin="psimin in "; 
 namedamin+=au;
 TString namedtmin="dtmin in ";
 namedtmin+=tux;
 matches.AddNamedSlot(namedamin);
 matches.AddNamedSlot(namedtmin);
 matches.AddNamedSlot("ipsi");
 matches.AddNamedSlot("idt");
 
 NcSignal data;
 TString nameda="psi in "; 
 nameda+=au;
 TString namedt="t2-t1 in ";
 namedt+=tux;
 data.AddNamedSlot("type1");
 data.AddNamedSlot("index1");
 data.AddNamedSlot("type2");
 data.AddNamedSlot("index2");
 data.AddNamedSlot(nameda);
 data.AddNamedSlot(namedt);
 
 if ((!itype || !jtype) && !fRefs)
 {
  printf(" *%-s::MatchSignals* Error: itype=%-i jtype=%-i but no reference signals are present. \n",ClassName(),itype,jtype); 
  return;
 }
 
 if ((itype || jtype) && !fSigs)
 {
  printf(" *%-s::MatchSignals* Error: itype=%-i jtype=%-i but no measurements are present. \n",ClassName(),itype,jtype); 
  return;
 }
 
 Int_t nrefs=0;
 if (fRefs) nrefs=fRefs->GetSize();
 Int_t nsigs=0;
 if (fSigs) nsigs=fSigs->GetSize();
 
 
 // Make input data consistent with conventions
 if (itype) itype=1;
 if (jtype) jtype=1;
 if (!itype)
 {
  if (i2<1 || i2>nrefs) i2=nrefs;
 }
 else
 {
  if (i2<1 || i2>nsigs) i2=nsigs;
 }
 if (!jtype)
 {
  if (j2<1 || j2>nrefs) j2=nrefs;
 }
 else
 {
  if (j2<1 || j2>nsigs) j2=nsigs;
 }
 
 if (i1<1 || j1<1 || i1>i2 || j1>j2)
 {
  printf(" *%-s::MatchSignals* Inconsistent parameters: i1=%-i i2=%-i itype=%-i j1=%-i j2=%-i jtype=%-i. \n",ClassName(),i1,i2,itype,j1,j2,jtype); 
  return;
 }
 
 Double_t dang,dtime;
 Int_t ix=0;
 Int_t jx=0;
 NcSignal* sx=0;
 Int_t id=0;
 Double_t dangmin=0;
 Double_t dtmin=0;
 Int_t idamin=0;
 Int_t idtmin=0;
 Bool_t first=kTRUE;
 for (Int_t i=i1; i<=i2; i++)
 {
  ix=i;
  if (itype) ix=-i;
 
  for (Int_t j=j1; j<=j2; j++)
  {
   // Skip matching a signal with itself
   if (itype==jtype && i==j) continue;
 
   jx=j;
   if (jtype) jx=-j;
 
   dang=GetSeparation(ix,jx,au,dtime,tu,mode,0);
 
   if ((fabs(dang)<=da || da<0) && (fabs(dtime)<=dt || dt<0)) 
   {
    data.Reset();
    name="Object1=";
    sx=GetSignal(i,itype);
    if (!sx) continue;
    name+=sx->GetName();
    title="Object2=";
    sx=GetSignal(j,jtype);
    if (!sx) continue;
    title+=sx->GetName();
    id++;
    data.SetNameTitle(name.Data(),title.Data());
    data.SetUniqueID(id);
    data.SetSignal(itype,"type1");
    data.SetSignal(i,"index1");
    data.SetSignal(jtype,"type2");
    data.SetSignal(j,"index2");
    data.SetSignal(dtime,namedt);
    data.SetSignal(dang,nameda);
    matches.AddHit(data);
 
    // Record the data for the minimal encountered opening angle
    if (first || fabs(dang)<dangmin)
    {
     dangmin=fabs(dang);
     idamin=id;
    }
 
    // Record the data for the minimal encountered time difference
    if (first || fabs(dtime)<fabs(dtmin))
    {
     dtmin=dtime;
     idtmin=id;
    }
    
    first=kFALSE;
   }
  }
 }
 
 // Store the data for the minimal encountered opening angle and time difference
 matches.SetSignal(dangmin,namedamin);
 matches.SetSignal(dtmin,namedtmin);
 matches.SetSignal(idamin,"ipsi");
 matches.SetSignal(idtmin,"idt");
}

void NcAstrolab::MatchSignals(NcDevice& matches,TString name,Double_t da,TString au,Double_t dt,TString tu,Int_t mode,Int_t itype,Int_t j1,Int_t j2,Int_t jtype)
{
 
 Int_t i=GetSignalIndex(name,itype);
 
 if (i==-1) // Add the info for the requested Solar system object if not already stored
 {
  SetSolarSystem(name,0,itype);
  i=GetSignalIndex(name,itype);
  if (i>0) fSolUpdate=1;
 }
 
 if (i<1)
 {
  printf(" *%-s::MatchSignals* Object %-s not found for itype=%-i. \n",ClassName(),name.Data(),itype); 
 }
 else
 {
  MatchSignals(matches,da,au,dt,tu,mode,i,i,itype,j1,j2,jtype);
 }
 
 fSolUpdate=0;
}

void NcAstrolab::SetTimeScramble(Int_t mode,Double_t tmin,Double_t tmax,TF1* frndm)
{
 
 fTscmode=mode;
 fTscmin=tmin;
 fTscmax=tmax;
 if (fTscfunc)
 {
  delete fTscfunc;
  fTscfunc=0;
 }
 if (frndm)
 {
  fTscfunc=new TF1(*frndm);
  if (tmax>tmin) fTscfunc->SetRange(tmin,tmax);
 }
}

Int_t NcAstrolab::GetTimeScramble(Double_t* tmin,Double_t* tmax,TF1* frndm)
{
 
 if (tmin) *tmin=fTscmin; 
 if (tmax) *tmax=fTscmax;
 if (frndm) *frndm=*fTscfunc;
 
 return fTscmode; 
}

void NcAstrolab::SetPositionScramble(Int_t mode,Double_t dmin,Double_t dmax,TF1* df,Double_t thmin,Double_t thmax,TF1* thf,Double_t phimin,Double_t phimax,TF1* phif)
{
 
 // Keep parameters within physical bounds for angular difference scrambling (mode=1)
 if (abs(mode)==1 && dmin<0) dmin=0;
 if (abs(mode)==1 && dmax>180) dmax=180;
 
 // Check for specific requested offsets
 if (dmax<dmin) dmax=dmin;
 if (thmax<thmin) thmax=thmin;
 if (phimax<phimin) phimax=phimin;
 
 fRscmode=mode;
 fDscmin=dmin;
 fDscmax=dmax;
 if (fDscfunc)
 {
  delete fDscfunc;
  fDscfunc=0;
 }
 if (df)
 {
  fDscfunc=new TF1(*df);
  if (dmax>dmin) fDscfunc->SetRange(dmin,dmax);
 }
 fThetascmin=thmin;
 fThetascmax=thmax;
 if (fThetascfunc)
 {
  delete fThetascfunc;
  fThetascfunc=0;
 }
 if (thf)
 {
  fThetascfunc=new TF1(*thf);
  if (thmax>thmin) fThetascfunc->SetRange(thmin,thmax);
 }
 fPhiscmin=phimin;
 fPhiscmax=phimax;
 if (fPhiscfunc)
 {
  delete fPhiscfunc;
  fPhiscfunc=0;
 }
 if (phif)
 {
  fPhiscfunc=new TF1(*phif);
  if (phimax>phimin) fPhiscfunc->SetRange(phimin,phimax);
 }
}

Int_t NcAstrolab::GetPositionScramble(Double_t* dmin,Double_t* dmax,TF1* df,Double_t* thmin,Double_t* thmax,TF1* thf,Double_t* phimin,Double_t* phimax,TF1* phif)
{
 
 if (dmin) *dmin=fDscmin; 
 if (dmax) *dmax=fDscmax;
 if (df) *df=*fDscfunc;
 if (thmin) *thmin=fThetascmin; 
 if (thmax) *thmax=fThetascmax;
 if (thf) *thf=*fThetascfunc;
 if (phimin) *phimin=fPhiscmin; 
 if (phimax) *phimax=fPhiscmax;
 if (phif) *phif=*fPhiscfunc;
 
 return fRscmode; 
}

void NcAstrolab::DisplaySignal(TString frame,TString mode,NcTimestamp* ts,Int_t j,TString proj,Int_t clr,TString name)
{
 
 // Comply with the new (jref,type) convention for measurements and reference signals.
 Int_t jref=abs(j);
 Int_t type=0;
 if (j<=0) type=1;
 if (!j) jref=1;
 
 NcSignal* sx=0;
 
 if (!ts)
 {
  sx=GetSignal(jref,type);
  if (!sx) return;
  ts=sx->GetTimestamp();
 }
 
 Nc3Vector r;
 sx=GetSignal(r,frame,mode,ts,jref,type);
 
 if (!sx) return;
 
 // Save name and timestamp to enable timestamp restoration for Solar system objects
 // after a Day View or Year View display 
 TString namesave=sx->GetName();
 NcTimestamp tsave=(*ts);
 
 // The generic input angles (in rad) for the projections 
 Double_t theta=0;
 Double_t phi=0;
 
 Double_t pi=acos(-1.);
 
 if (frame=="equ" || frame=="gal" || frame=="icr" || frame=="ecl" || frame=="loc")
 {
  theta=(pi/2.)-r.GetX(2,"sph","rad");
  phi=r.GetX(3,"sph","rad");
 }
 
 if (frame=="hor")
 {
  theta=(pi/2.)-r.GetX(2,"sph","rad");
  phi=pi-r.GetX(3,"sph","rad");
 }
 
 // Automatic choice of central meridian if not selected by the user
 if (!fUsMeridian || abs(fUsMeridian)>1)
 {
  if (frame=="equ")
  {
   fMeridian=pi;
   fUsMeridian=-2;
  }
  if (frame=="gal" || frame=="icr" || frame=="ecl")
  {
   fMeridian=0;
   fUsMeridian=-2;
  }
  if (frame=="hor" || frame=="loc")
  {
   fMeridian=0;
   fUsMeridian=2;
  }
 }
 
 // Obtain the projected (x,y) position
 Double_t x=0;
 Double_t y=0;
 Project(phi,theta,proj,x,y);
 
 // X-axis inversion of the display
 if (fUsMeridian<0) x*=-1.;
 
 Int_t hist=0;
 if (proj=="hamh" || proj=="aith" || proj=="merh" || proj=="cylh" || proj=="angh") hist=1;
 if (proj=="UTh" || proj=="LTh" || proj=="GSTh" || proj=="LSTh") hist=1;
 if (proj=="UYh" || proj=="LYh" || proj=="GSYh" || proj=="LSYh") hist=1;
 
 // Update the display for this signal position
 
 // Create a new canvas if needed
 if (!fCanvas || !(gROOT->GetListOfCanvases()->FindObject("NcAstrolab"))) fCanvas=new TCanvas("NcAstrolab","Skymap");
 
 // Construct the various strings for this map
 TString titleup;  // The upper title string
 TString titlelow; // The lower title string
 TString sleft;    // The most left coordinate indicator
 TString sright;   // The most right coordinate indicator
 TString sup;      // The most upper coordinate indicator
 TString slow;     // The most lower coordinate indicator
 sup="90#circ";
 slow="-90#circ";
 if (name!="")
 {
  titleup=name;
  titleup+=" ";
 }
 if (frame=="equ")
 {
  titleup+="Geocentric Equatorial (";
  titleup+=mode;
  if (mode=="J") titleup+="2000";
  if (mode=="B") titleup+="1950";
  titleup+=") ";
 }
 if (frame=="gal") titleup+="Heliocentric Galactic";
 if (frame=="ecl") titleup+=" Geocentric Ecliptic";
 if (frame=="hor") titleup+="  Standard Horizon";
 if (frame=="icr") titleup+="Static Barycentric ICRS";
 if (frame=="loc")
 {
  titleup+=" User defined Local";
  sup=" 0#circ";
  slow="180#circ";
 }
 titleup+=" Coordinates";
 titlelow="Projection : ";
 if (proj=="ham" || proj=="hamh") titlelow+="Hammer";
 if (proj=="cyl" || proj=="cylh") titlelow+="Cylindrical";
 if (proj=="ait" || proj=="aith") titlelow+="Aitoff";
 if (proj=="mer" || proj=="merh") titlelow+="Mercator";
 if (proj=="ang" || proj=="angh")
 {
  titlelow+="sin(b) vs. l";
  sup=" 1";
  slow=" -1";
 }
 titlelow+="   Central Meridian : ";
 Int_t ang,h,m,s,d;
 Int_t angmax,hmin,hmax,dmin,dmax;
 TString corr;
 TString scenter="";
 if (frame=="equ")
 {
  ang=int(ConvertAngle(fMeridian,"rad","hms"));
  angmax=ang+120000;
  h=ang/10000;
  ang=ang%10000;
  m=ang/100;
  s=ang%100;
  titlelow+=h;
  titlelow+="h ";
  titlelow+=m;
  titlelow+="m ";
  titlelow+=s;
  titlelow+="s";
  hmax=angmax/10000;
  corr="";
  while (hmax>24)
  {
   hmax-=24;
   corr="+";
  }
  hmin=hmax-24;
  while (hmin<-12)
  {
   hmin+=24;
   corr="+";
  }
  sright+=corr;
  if (fUsMeridian<0)
  {
   sright+=hmin;
  }
  else
  {
   sright+=hmax;
  }
  sright+="h";
  if (fUsMeridian<0)
  {
   sleft+=hmax;
  }
  else
  {
   sleft+=hmin;
  }
  sleft+="h";
  scenter+=h;
  scenter+="h";
 }
 else
 {
  ang=int(ConvertAngle(fMeridian,"rad","dms"));
  angmax=ang+1800000;
  d=ang/10000;
  ang=ang%10000;
  m=ang/100;
  s=ang%100;
  titlelow+=d;
  titlelow+="d ";
  titlelow+=m;
  titlelow+="' ";
  titlelow+=s;
  titlelow+="\"";
  dmax=angmax/10000;
  corr="";
  while (dmax>360)
  {
   dmax-=360;
   corr="+";
  }
  dmin=dmax-360;
  while (dmin<-180)
  {
   dmin+=360;
   corr="+";
  }
  sright+=corr;
  if (fUsMeridian<0)
  {
   sright+=dmin;
  }
  else
  {
   sright+=dmax;
  }
  sright+="#circ";
  if (fUsMeridian<0)
  {
   sleft+=dmax;
  }
  else
  {
   sleft+=dmin;
  }
  sleft+="#circ";
  scenter+=d;
  scenter+="#circ";
 }
 
 if (!hist) // 2-D Marker display (i.e. not a histogram) 
 {
  TMarker* marker=0;
  // Remove existing markers, grid and outline from display if needed
  if (clr==1 || proj!=fProj)
  {
   if (fMarkers)
   {
    delete fMarkers;
    fMarkers=0;
   }
   fCanvas->Clear();
   fProj=proj;
  }
 
  // Create a new display if needed
  if (!fMarkers)
  {
   fMarkers=new TObjArray();
   fMarkers->SetOwner();
 
   // Set canvas range, header and axes
   Float_t xup=2; // Maximal x coordinate of the projection
   Float_t yup=1; // maximal y coordinate of the projection
   Float_t xlow=-xup;
   Float_t ylow=-yup;
   Float_t xmargin=0.5; // X margin for canvas size
   Float_t ymargin=0.3; // Y margin for canvas size
   fCanvas->Range(xlow-xmargin,ylow-ymargin,xup+xmargin,yup+ymargin);
 
   // The ellipse outline with the skymap c.q. projection grid
   if (proj=="ham" || proj=="ait")
   {
    // Draw ellips outline
    TEllipse* outline=new TEllipse(0,0,xup,yup);
    fMarkers->Add(outline);
    outline->Draw();
   } 

   // Draw the skymap c.q. projection grid //
 
   // Drawing of the projected meridians every 30 degrees
   const Int_t nphi=13;
   Double_t gphiarr[nphi]={0,30,60,90,120,150,180,210,240,270,300,330,360};
   Double_t gphi=0;
   Double_t gtheta=0;
   Int_t ndots=100;
   Float_t gstep=180./float(ndots);
   Double_t xgrid=0;
   Double_t ygrid=0;
   for (Int_t iph=0; iph<nphi; iph++)
   {
    gphi=gphiarr[iph]*pi/180.;
    if (frame=="hor") gphi=pi-gphi;
    gtheta=pi/2.;
    for (Int_t ith=1; ith<ndots; ith++)
    {
     gtheta=gtheta-(gstep*pi/180.);
     Project(gphi,gtheta,proj,xgrid,ygrid);
     marker=new TMarker(xgrid,ygrid,fMarkerStyle[3]);
     marker->SetMarkerSize(fMarkerSize[3]);
     marker->SetMarkerColor(fMarkerColor[3]);
     fMarkers->Add(marker);
     marker->Draw();
    }
   } 
 
   // Drawing of the projected latitude circles every 15 degrees
   const Int_t nth=10;
   Double_t gtharr[nth]={15,30,45,60,75,105,120,135,150,165};
   gphi=0;
   gtheta=0;
   gstep=360./float(ndots);
   TString gs;
   Int_t igs=0;
   TLatex* lgs=0;
   Double_t xtext=0;
   Double_t ytext=0;
   for (Int_t ith=0; ith<nth; ith++)
   {
    gtheta=pi/2.-(gtharr[ith]*pi/180.);
    igs=int(90.-gtharr[ith]);
    if (frame=="loc") igs=int(gtharr[ith]);
    gs="";
    gs+=igs;
    gs+="#circ";
    xtext=0;
    for (Int_t iphi=1; iphi<ndots; iphi++)
    {
     gphi=gphi+gstep;
     Project(gphi,gtheta,proj,xgrid,ygrid);
     marker=new TMarker(xgrid,ygrid,fMarkerStyle[3]);
     marker->SetMarkerSize(fMarkerSize[3]);
     marker->SetMarkerColor(fMarkerColor[3]);
     if (xgrid<xtext)
     {
      xtext=xgrid;
      ytext=ygrid;
     }
     fMarkers->Add(marker);
     marker->Draw();
    }
    lgs=new TLatex;
    fMarkers->Add(lgs);
    if (ytext>0)
    {
     if (proj=="ham" || proj=="ait")
     {
      lgs->DrawLatex(xtext-0.25,ytext,gs.Data());
     }
     else
     {
      lgs->DrawLatex(xtext-0.4,ytext-0.02,gs.Data());
     }
    }
    else
    {
     if (proj=="ham" || proj=="ait")
     {
      lgs->DrawLatex(xtext-0.3,ytext-0.1,gs.Data());
     }
     else
     {
      lgs->DrawLatex(xtext-0.4,ytext-0.02,gs.Data());
     }
    }
   } 
 
   // The horizontal and vertical axes
   TLine* line=new TLine(xlow,0,xup,0);
   fMarkers->Add(line);
   line->Draw();
   line=new TLine(0,yup,0,ylow);
   fMarkers->Add(line);
   line->Draw();
 
   // The header and footer text
   TLatex* header=new TLatex;
   fMarkers->Add(header);
   header->SetTextAlign(21); // Text will be horizontally centered
   header->DrawLatex(0,yup+0.2,titleup.Data());
   TLatex* footer=new TLatex;
   fMarkers->Add(footer);
   footer->SetTextAlign(21); // Text will be horizontally centered
   footer->DrawLatex(0,ylow-0.25,titlelow.Data());
 
   // The left side angular value indicator
   TLatex* left=new TLatex;
   fMarkers->Add(left);
   if (proj=="ham" || proj=="ait")
   {
    left->DrawLatex(xlow-0.4,0,sleft.Data());
   }
   else
   {
    left->DrawLatex(xlow-0.15,yup+0.05,sleft.Data());
   }
   // The right side angular value indicator
   TLatex* right=new TLatex;
   fMarkers->Add(right);
   if (proj=="ham" || proj=="ait")
   {
    right->DrawLatex(xup+0.1,0,sright.Data());
   }
   else
   {
    right->DrawLatex(xup-0.1,yup+0.05,sright.Data());
   }
   // The upper angular value indicator
   TLatex* up=new TLatex;
   fMarkers->Add(up);
   if (proj=="ham" || proj=="ait")
   {
    up->DrawLatex(-0.1,yup+0.05,sup.Data());
   }
   else
   {
    up->DrawLatex(-0.1,yup+0.05,scenter.Data());
    if (proj!="ang")
    {
     up=new TLatex;
     fMarkers->Add(up);
     up->DrawLatex(xlow-0.4,yup-0.04,sup.Data());
    }
   }
   // The lower angular value indicator
   TLatex* low=new TLatex;
   fMarkers->Add(low);
   if (proj=="ham" || proj=="ait")
   {
    low->DrawLatex(-0.15,ylow-0.15,slow.Data());
   }
   else
   {
    if (proj!="ang") low->DrawLatex(xlow-0.4,ylow,slow.Data());
   }

   // Indicate the Galactic Center //
 
   // Add the Galactic Center temporarily as a reference signal for coordinate retrieval
   sx=SetSignal(1,0,"deg",0,"deg","gal",0,-1,"J","GC",0);
   Int_t idx=fRefs->IndexOf(sx);
   idx++;
   Nc3Vector rgc;
   sx=GetSignal(rgc,frame,mode,ts,idx,0);
   if (sx)
   {
    Double_t thetagc=0;
    Double_t phigc=0;
    if (frame=="equ" || frame=="gal" || frame=="icr" || frame=="ecl" || frame=="loc")
    {
     thetagc=(pi/2.)-rgc.GetX(2,"sph","rad");
     phigc=rgc.GetX(3,"sph","rad");
    }
    if (frame=="hor")
    {
     thetagc=(pi/2.)-rgc.GetX(2,"sph","rad");
     phigc=pi-rgc.GetX(3,"sph","rad");
    }
    // Obtain the projected (x,y) position
    Double_t xgc=0;
    Double_t ygc=0;
    Project(phigc,thetagc,proj,xgc,ygc);
    if (fUsMeridian<0) xgc*=-1.;
    marker=new TMarker(xgc,ygc,fMarkerStyle[2]);
    marker->SetMarkerSize(fMarkerSize[2]);
    marker->SetMarkerColor(fMarkerColor[2]);
    fMarkers->Add(marker);
    marker->Draw();
    // Remove the temporary Galactic Center object again
    RemoveSignal(idx,0,0);
   }
  }
 
  // Indicate the measurement(s) or reference signal(s) on the display
  marker=new TMarker(x,y,fMarkerStyle[type]);
  marker->SetMarkerSize(fMarkerSize[type]);
  marker->SetMarkerColor(fMarkerColor[type]);
  fMarkers->Add(marker);
  marker->Draw();
 }
 else if (hist==1) // 2-D display via histogram
 {
  Float_t xfac=90;
  Float_t yfac=90;
  if (frame=="equ") xfac=6;
  if (proj=="angh") yfac=1;
  // Reset the histogram if needed
  if (clr==1 || proj!=fProj || !fHist[type])
  {
   if (clr==1 || proj!=fProj)
   {
    fCanvas->Clear();
    fCanvas->SetGrid();
    for (Int_t i=0; i<2; i++)
    {
     if (fHist[i])
     {
      fHist[i]->Delete();
      fHist[i]=0;
     }
    }
   }
   if (!fHist[type]) fHist[type]=new TH2F();
   fHist[type]->Reset();
   fHist[type]->SetMarkerStyle(fMarkerStyle[type]);
   fHist[type]->SetMarkerSize(fMarkerSize[type]);
   fHist[type]->SetMarkerColor(fMarkerColor[type]);
   TString title=titleup;
   title+="   ";
   title+=titlelow;
   fHist[type]->SetNameTitle("SkyMap",title.Data());
   fHist[type]->GetXaxis()->SetTitle("Degrees from central Meridian");
   if (proj=="angh")
   {
    fHist[type]->SetBins(1000,-181,181,100,-1.1,1.1);
    fHist[type]->GetYaxis()->SetTitle("sin(b)");
   }
   else
   {
    fHist[type]->SetBins(1000,-181,181,500,-91,91);
    fHist[type]->GetYaxis()->SetTitle("Projected Latitude in degrees");
   }
   if (frame=="equ")
   {
    fHist[type]->GetXaxis()->SetTitle("Hours from central Meridian");
    if (proj=="angh")
    {
     fHist[type]->SetBins(200,-12.1,12.1,100,-1.1,1.1);
     if (frame=="equ") fHist[type]->GetYaxis()->SetTitle("sin(#delta)");
    }
    else
    {
     fHist[type]->SetBins(200,-12.1,12.1,500,-91,91);
     if (frame=="equ") fHist[type]->GetYaxis()->SetTitle("Projected Declination in degrees");
    }
   }
   if (frame=="hor")
   {
    if (proj=="angh")
    {
     fHist[type]->GetYaxis()->SetTitle("sin(alt)=cos(zenith)");
    }
    else
    {
     fHist[type]->GetYaxis()->SetTitle("Projected Altitude in degrees");
    }
   }
   if (frame=="loc")
   {
    if (proj=="angh")
    {
     fHist[type]->GetYaxis()->SetTitle("cos(#theta)=sin(b)");
    }
    else
    {
     fHist[type]->GetYaxis()->SetTitle("Projected degrees from the equator");
    }
   }
   fProj=proj;
  }
 
  if (proj=="merh")
  {
   fHist[type]->Fill(x*xfac,theta*180./pi);
  }
  else if (proj=="hamh" || proj=="aith" || proj=="cylh" || proj=="angh")
  {
   fHist[type]->Fill(x*xfac,y*yfac);
  }
  else if (proj=="UTh" || proj=="LTh" || proj=="GSTh" || proj=="LSTh") // The 24 hour day view
  {
   // Set histogram binning and axes attributes
   fHist[type]->SetBins(100,0,24,181,-90.5,90.5);
   if (!ts) ts=(NcTimestamp*)this;
   NcTimestamp tx=(*ts);
   Double_t toffset=GetLabTimeOffset();
   TString title="Day view";
   if (name!="")
   {
    title+=" of ";
    title+=name;
   }
   title+=" at ";
   title+=GetName();
   title+=" on ";
   TString date;
   ts->GetDayTimeString("UT",0,0,&date);
   title+=date;
   TString tmode="UT";
   if (proj=="LTh") tmode="LMT";
   if (proj=="GSTh")
   {
    tmode="GMST";
    if (mode=="T") tmode="GAST";
   }
   if (proj=="LSTh")
   {
    tmode="LMST";
    if (mode=="T") tmode="LAST";
   }
   if (proj=="UTh") title+=";Universal Time";
   if (proj=="LTh") title+=";Local Time";
   if (proj=="GSTh") title+=";Greenwich Sidereal Time";
   if (proj=="LSTh") title+=";Local Sidereal Time";
   if (proj!="UTh")
   {
    title+=" (";
    title+=tmode;
    title+=")";
   }
   title+=" in hours;";
   TString ytitle="Declination ";
   if (frame=="equ" && mode=="J") ytitle+="(J2000)";
   if (frame=="equ" && mode=="B") ytitle+="(B1950)";
   if (frame=="equ" && mode=="M") ytitle+="(Mean)";
   if (frame=="equ" && mode=="T") ytitle+="(True)";
   if (frame=="gal") ytitle="Galactic latitude";
   if (frame=="ecl") ytitle="Geocentric Ecliptic latitude";
   if (frame=="hor") ytitle="Horizon altitude";
   if (frame=="icr") ytitle="ICRS latitude";
   if (frame=="loc") ytitle="Angle w.r.t. local frame equator";
   ytitle+=" in degrees";
   title+=ytitle;
   fHist[type]->SetTitle(title);
   fHist[type]->SetStats(kFALSE);
 
   // Fill the day view histogram
   Double_t hour=0;
   Double_t d,a,b;
   for (Int_t i=0; i<24; i++)
   {
    if (tmode=="UT") hour=tx.GetUT();
    if (tmode=="LMT") hour=tx.GetLT(toffset);
    if (tmode=="GMST") hour=tx.GetGMST();
    if (tmode=="GAST") hour=tx.GetGAST();
    if (tmode=="LMST") hour=tx.GetLMST(toffset);
    if (tmode=="LAST") hour=tx.GetLAST(toffset);
 
    // Get coordinates at this time step
    GetSignal(d,a,"deg",b,"deg",frame,&tx,jref,mode,type);
    
    if (frame=="hor") b=90.-b;
    if (frame=="loc") b=90.-a;
 
    fHist[type]->Fill(hour,b);
 
    tx.Add(1); // Add 1 hour for each time step
   }
 
   // Restore the original timestamp for Solar system objects
   SetSolarSystem(namesave,&tsave,type);
  }
  else if (proj=="UYh" || proj=="LYh" || proj=="GSYh" || proj=="LSYh") // The day of the year view
  {
   // Set histogram binning and axes attributes
   fHist[type]->SetBins(1500,0,370,181,-90.5,90.5);
   if (!ts) ts=(NcTimestamp*)this;
   NcTimestamp tx=(*ts);
   Double_t toffset=GetLabTimeOffset();
   TString year="";
   year+=int(ts->GetEpoch("J"));
   TString tmode="UT";
   if (proj=="LYh") tmode="LMT";
   if (proj=="GSYh")
   {
    tmode="GMST";
    if (mode=="T") tmode="GAST";
   }
   if (proj=="LSYh")
   {
    tmode="LMST";
    if (mode=="T") tmode="LAST";
   }
   TString time;
   if (proj=="UYh" || proj=="GSYh") ts->GetDayTimeString(tmode,0,0,0,&time);
   if (proj=="LYh" || proj=="LSYh") ts->GetDayTimeString(tmode,0,toffset,0,&time);
 
   TString title="Year view";
   if (name!="")
   {
    title+=" of ";
    title+=name;
   }
   title+=" at ";
   title+=GetName();
   title+=" in ";
   title+=year;
   title+=" at ";
   title+=time;
   title+=";Day of the year;";
   TString ytitle="Declination ";
   if (frame=="equ" && mode=="J") ytitle+="(J2000)";
   if (frame=="equ" && mode=="B") ytitle+="(B1950)";
   if (frame=="equ" && mode=="M") ytitle+="(Mean)";
   if (frame=="equ" && mode=="T") ytitle+="(True)";
   if (frame=="gal") ytitle="Galactic latitude";
   if (frame=="ecl") ytitle="Geocentric Ecliptic latitude";
   if (frame=="hor") ytitle="Horizon altitude";
   if (frame=="icr") ytitle="ICRS latitude";
   if (frame=="loc") ytitle="Angle w.r.t. local frame equator";
   ytitle+=" in degrees";
   title+=ytitle;
   fHist[type]->SetTitle(title);
   fHist[type]->SetStats(kFALSE);
 
   // Fill the year view histogram
   // Start at 01-jan 00:00:00h for the corresponding year at the selected location
   // and then set the time according to the specified timestamp
   Double_t hour=0;
   if (proj=="UYh" || proj=="GSYh") // Location is Greenwich
   {
    tx.SetUT(year.Atoi(),1,1,"00:00:00");
    hour=ts->GetUT();
   }
   if (proj=="LYh" || proj=="LSYh") // The lab location
   {
    tx.SetLT(toffset,year.Atoi(),1,1,"00:00:00");
    hour=ts->GetLT(toffset);
   }
   tx.Add(hour); // Set the selected time
 
   Double_t d,a,b;
   Int_t day=0;
   for (Int_t i=0; i<367; i++)
   {
 
    // Get coordinates at this time step
    GetSignal(d,a,"deg",b,"deg",frame,&tx,jref,mode,type);
    
    if (frame=="hor") b=90.-b;
    if (frame=="loc") b=90.-a;
 
    if (proj=="UYh" || proj=="GSYh") day=tx.GetDayOfYear();
    if (proj=="LYh" || proj=="LSYh") day=tx.GetDayOfYear(kFALSE,toffset);
 
    fHist[type]->Fill(day,b);
 
    tx.Add(24); // Add 1 day (= 24 hours) for each time step
   }
 
   // Restore the original timestamp for Solar system objects
   SetSolarSystem(namesave,&tsave,type);
  }
 
  // Draw the selected histogram
  if ((!type && fHist[1]) || (type && fHist[0]))
  {
   fHist[type]->Draw("same");
  }
  else
  {
   fHist[type]->Draw();
 
   // Draw a horizontal thick line to mark the horizon c.q. equator for the day and year views
   if (proj=="UTh" || proj=="LTh" || proj=="GSTh" || proj=="LSTh" ||
       proj=="UYh" || proj=="LYh" || proj=="GSYh" || proj=="LSYh")
   {
    if (!fMarkers)
    {
     fMarkers=new TObjArray();
     fMarkers->SetOwner();
    }
    TLine* line=0;
    if (proj=="UTh" || proj=="LTh" || proj=="GSTh" || proj=="LSTh") line=new TLine(0,0,24,0);
    if (proj=="UYh" || proj=="LYh" || proj=="GSYh" || proj=="LSYh") line=new TLine(0,0,370,0);
    if (line)
    {
     line->SetLineWidth(3);
     fMarkers->Add(line);
     line->Draw();
    }
   }
  }
 }
}

void NcAstrolab::DisplaySignal(TString frame,TString mode,NcTimestamp* ts,TString name,TString proj,Int_t clr,Int_t type)
{
 
 // Create a signal for a solar system object if needed
 Double_t d,a,b;
 GetSignal(d,a,"deg",b,"deg",frame,ts,name,mode,type);
  
 Int_t j=GetSignalIndex(name,type);
 if (j>0)
 {
  if (type) j=-j;
  DisplaySignal(frame,mode,ts,j,proj,clr,name);
 }
 
 // Update the canvas so that the Skymap GUI immediately shows the result
 if (fCanvas) fCanvas->Update();
}

void NcAstrolab::DisplaySignals(TString frame,TString mode,NcTimestamp* ts,TString proj,Int_t clr,Int_t nmax,Int_t j,Int_t type,TString name)
{
 
 NcSignal* sx=0;
 TString namex="";
 NcTimestamp* tx=0;
 Int_t jdisp=0;
 
 // Display stored reference signals
 if (fRefs && type<=0)
 {
  // Use timestamp of j-th measurement if requested
  if (j>0)
  {
   sx=GetSignal(j,1);
   if (sx) tx=sx->GetTimestamp();
  }
 
  // Use the provided timestamp
  if (!j || !tx) tx=ts;
 
  // Use the current lab timestamp if no timestamp selected
  if (!tx) tx=(NcTimestamp*)this;
 
  jdisp=0;
  for (Int_t i=1; i<=fRefs->GetSize(); i++)
  {
   sx=GetSignal(i,0);
   if (!sx) continue;
 
   jdisp++;
   if (nmax>=0 && jdisp>nmax) break;
 
   // Check for the name pattern
   namex=sx->GetName();
   if (name!="*" && !namex.Contains(name)) continue;
 
   // Use the actual timestamp of the reference signal
   if (j<0)
   {
    tx=sx->GetTimestamp();
    if (!tx) tx=ts;
    if (!tx) tx=(NcTimestamp*)this;
   }
 
   if (name=="*")
   {
    DisplaySignal(frame,mode,tx,i,proj,clr);
   }
   else
   {
    DisplaySignal(frame,mode,tx,i,proj,clr,name);
   }
   clr=0; // No display clear for subsequent signals
  }
 }
 
 // Display all stored measurements
 if (fSigs && type)
 {
  jdisp=0;
  for (Int_t j=1; j<=fSigs->GetSize(); j++)
  {
   sx=GetSignal(j,1);
   if (!sx) continue;
 
   jdisp++;
   if (nmax>=0 && jdisp>nmax) break;
 
   // Check for the name pattern
   namex=sx->GetName();
   if (name!="*" && !namex.Contains(name)) continue;
 
   tx=sx->GetTimestamp();
   if (!tx) tx=ts;
   if (!tx) tx=(NcTimestamp*)this;
   if (name=="*")
   {
    DisplaySignal(frame,mode,tx,-j,proj,clr);
   }
   else
   {
    DisplaySignal(frame,mode,tx,-j,proj,clr,name);
   }
   clr=0; // No display clear for subsequent signals
  }
 }
 
 // Update the canvas so that the Skymap GUI immediately shows the result
 if (fCanvas) fCanvas->Update();
}

void NcAstrolab::SetMarkerSize(Float_t size,Int_t type)
{
 
 if (type<0 || type >3) return;
 
 fMarkerSize[type]=size;
}

void NcAstrolab::SetMarkerStyle(Int_t style,Int_t type)
{
 
 if (type<0 || type >3) return;
 
 fMarkerStyle[type]=style;
}

void NcAstrolab::SetMarkerColor(Int_t color,Int_t type)
{
 
 if (type<0 || type >3) return;
 
 fMarkerColor[type]=color;
}

void NcAstrolab::SetCentralMeridian(Int_t mode,Double_t phi,TString u)
{
 
 fMeridian=ConvertAngle(phi,u,"rad");
 fUsMeridian=0;
 if (mode>0) fUsMeridian=1;
 if (mode<0) fUsMeridian=-1;
 Double_t pi=acos(-1.);
 Double_t twopi=2.*pi;
 // Set range to 0 <= meridian < 2pi
 while (fMeridian>=twopi)
 {
  fMeridian-=twopi;
 }
 while (fMeridian<0)
 {
  fMeridian+=twopi;
 }
 // Prevent accuracy problems
 if (fMeridian>0) fMeridian+=1.e-6;
}

void NcAstrolab::Project(Double_t l,Double_t b,TString proj,Double_t& x,Double_t& y)
{
 
 Double_t pi=acos(-1.);
 
 // Subtract central meridian from longitude
 l-=fMeridian;
 
 // Take l between -180 and 180 degrees
 while (l>pi)
 {
  l-=2.*pi;
 }
 while (l<-pi)
 {
  l+=2.*pi;
 }
 
 x=0;
 y=0;
 
 // Convert (l,b) to (x,y) with -2 < x <= 2 
 if (proj=="cyl" || proj=="cylh") ProjectCylindrical(l,b,x,y);
 if (proj=="ham" || proj=="hamh") ProjectHammer(l,b,x,y);
 if (proj=="ait" || proj=="aith") ProjectAitoff(l,b,x,y);
 if (proj=="mer" || proj=="merh") ProjectMercator(l,b,x,y);
 if (proj=="ang" || proj=="angh")
 {
  x=2.*l/pi;
  y=sin(b);
 }
}

void NcAstrolab::ProjectCylindrical(Double_t l,Double_t b,Double_t& x, Double_t& y)
{
 
 Double_t pi=acos(-1.);
 x=2.*l/pi;
 y=2.*b/pi;
}

void NcAstrolab::ProjectHammer(Double_t l,Double_t b,Double_t& x,Double_t& y)
{
 
 Double_t k=1./sqrt(1.+cos(b)*cos(l/2.));
 x=2.*k*cos(b)*sin(l/2.);
 y=k*sin(b);
}

void NcAstrolab::ProjectAitoff(Double_t l,Double_t b,Double_t& x,Double_t& y)
{
 
 Double_t pi=acos(-1.);
 x=0;
 y=0;
 Double_t k=acos(cos(b)*cos(l/2.));
 if(sin(k)!=0)
 {
  x=4.*k*cos(b)*sin(l/2.)/(pi*sin(k));
  y=2.*k*sin(b)/(pi*sin(k));
 }
}

void NcAstrolab::ProjectMercator(Double_t l,Double_t b,Double_t& x,Double_t& y)
{
 
 Double_t pi=acos(-1.);
 Double_t bcut=85.051*pi/180.; // Latitude cut off value in radians
 
 x=2.*l/pi;
 y=0;
 if (b > bcut) b=bcut;
 if (b < -bcut) b=-bcut;
 y=0.5*log((1.+sin(b))/(1.-sin(b)))/pi;
}

void NcAstrolab::SetPhysicalParameter(TString name,Double_t value)
{
 
 // Variable to correct conversion factors when a parameter is modified
 Double_t frac=1;
 
 if (name=="SpeedC")
 {
  frac=value/fSpeedC;
  fSpeedC=value;
  fMe*=frac*frac;
  fMmu*=frac*frac;
  fMtau*=frac*frac;
  fAmu*=frac*frac;
  fMp*=frac*frac;
  fMn*=frac*frac;
  fMW*=frac*frac;
  fMZ*=frac*frac;
  fHbarc*=frac;
  fHbarc2*=pow(frac,2.);
 }
 if (name=="Qe")
 {
  frac=value/fQe;
  fQe=value;
  fMe/=frac;
  fMmu/=frac;
  fMtau/=frac;
  fAmu/=frac;
  fMp/=frac;
  fMn/=frac;
  fMW/=frac;
  fMZ/=frac;
  fHbar/=frac;
  fHbarc/=frac;
  fHbarc2/=pow(frac,2.);
 }
 if (name=="Me") fMe=value;
 if (name=="Mmu") fMmu=value;
 if (name=="Mtau") fMtau=value;
 if (name=="Amu")
 {
  frac=value/fAmu;
  fAmu=value;
  fMp*=frac;
  fMn*=frac;
 }
 if (name=="Mp") fMp=value;
 if (name=="Mn") fMn=value;
 if (name=="MW") fMW=value;
 if (name=="GammaW") fGammaW=value;
 if (name=="MZ") fMZ=value;
 if (name=="GammaZ") fGammaZ=value;
 if (name=="AlphaEM") fAlphaEM=value;
 if (name=="Fermi") fFermi=value;
 if (name=="Planck")
 {
  frac=value/fPlanck;
  fPlanck=value;
  fHbar*=frac;
  fHbarc*=frac;
  fFermi/=pow(frac,3.);
 }
 if (name=="Boltz") fBoltz=value;
 if (name=="Newton")
 {
  frac=value/fNewton;
  fNewton=value;
  fGn*=frac;
 }
 if (name=="Gn") fGn=value;
 if (name=="Au") fAu=value;
 if (name=="Pc") fPc=value;
 if (name=="Hubble") fHubble=value;
 if (name=="OmegaM") fOmegaM=value;
 if (name=="OmegaR") fOmegaR=value;
 if (name=="OmegaL") fOmegaL=value;
 if (name=="OmegaB") fOmegaB=value;
 if (name=="OmegaC") fOmegaC=value;
}

Double_t NcAstrolab::GetPhysicalParameter(TString name) const
{
 
 Double_t val=0;
 
 // Standard parameters
 if (name=="SpeedC") return fSpeedC;
 if (name=="Qe") return fQe;
 if (name=="Me") return fMe;
 if (name=="Mmu") return fMmu;
 if (name=="Mtau") return fMtau;
 if (name=="Amu") return fAmu;
 if (name=="Mp") return fMp;
 if (name=="Mn") return fMn;
 if (name=="MW") return fMW;
 if (name=="GammaW") return fGammaW;
 if (name=="GammaZ") return fGammaZ;
 if (name=="AlphaEM") return fAlphaEM;
 if (name=="Fermi") return fFermi;
 if (name=="Planck") return fPlanck;
 if (name=="Boltz") return fBoltz;
 if (name=="Newton") return fNewton;
 if (name=="Gn") return fGn;
 if (name=="Au") return fAu;
 if (name=="Pc") return fPc;
 if (name=="Hubble") return fHubble;
 if (name=="OmegaM") return fOmegaM;
 if (name=="OmegaR") return fOmegaR;
 if (name=="OmegaL") return fOmegaL;
 if (name=="OmegaB") return fOmegaB;
 if (name=="OmegaC") return fOmegaC;
 
 // Derived parameters
 if (name=="Hbar") return fHbar;
 if (name=="Hbarc") return fHbarc;
 if (name=="Hbarc2") return fHbarc2;
 if (name=="Mnucl")
 {
  val=(fMp+fMn)/2.;
  return val;
 }
 if (name=="Sin2w")
 {
  val=1.-pow(fMW/fMZ,2.);
  return val;
 }
 if (name=="Jy") return 1e-23;
 if (name=="Erg")
 {
  val=1e-7/(fQe*1e9);
  return val;
 }
 
 // Unknown parameter
 return 0;
}

Double_t NcAstrolab::GetPhysicalDistance(Double_t z,TString u,Int_t t) const
{
 
 if (z<=0 || fHubble<=0) return 0;
 
 Double_t c=fSpeedC/1000.; // Lightspeed in km/s
 
 TF1 f("f","1./sqrt([0]*pow((1.+x),4)+[1]*pow((1.+x),3)+[2])");
 
 f.SetParameter(0,fOmegaR);
 f.SetParameter(1,fOmegaM);
 f.SetParameter(2,fOmegaL);
 f.SetRange(0,z);
 
 Double_t dist=f.Integral(0,z);
 dist*=c/fHubble; // The distance in Mpc
 
 Double_t distm=dist*1e6*fPc; // corresponding distance in meter
 
 Double_t val=0;
 
 if (u=="Gpc") val=dist*1e-3;
 if (u=="Mpc") val=dist;
 if (u=="pc") val=dist*1e6;
 if (u=="ly") val=dist*3.26156e6;
 if (u=="m") val=distm;
 if (u=="km") val=distm*1e-3;
 if (u=="cm") val=distm*1e2;
 
 if (!t) val=val/(z+1.);
 
 return val;
}

Double_t NcAstrolab::GetProperDistance(Double_t z,TString u,Int_t t) const
{
 
 Double_t val=GetPhysicalDistance(z,u,t);
 
 return val;
}

Double_t NcAstrolab::GetComovingDistance(Double_t z,TString u) const
{
 
 Double_t val=GetPhysicalDistance(z,u,1);
 
 return val;
}

Double_t NcAstrolab::GetLuminosityDistance(Double_t z,TString u) const
{
 
 Double_t val=GetPhysicalDistance(z,u,1);
 val=val*(z+1.);
 
 return val;
}

Double_t NcAstrolab::GetLightTravelDistance(Double_t z,TString u) const
{
 
 if (z<=0 || fHubble<=0) return 0;
 
 Double_t c=fSpeedC/1000.; // Lightspeed in km/s
 
 TF1 f("f","1./((1.+x)*sqrt([0]*pow((1.+x),4)+[1]*pow((1.+x),3)+[2]))");
 
 f.SetParameter(0,fOmegaR);
 f.SetParameter(1,fOmegaM);
 f.SetParameter(2,fOmegaL);
 f.SetRange(0,z);
 
 Double_t dist=f.Integral(0,z);
 dist*=c/fHubble; // The distance in Mpc
 
 Double_t distm=dist*1e6*fPc; // corresponding distance in meter
 
 Double_t val=0;
 
 if (u=="Gpc") val=dist*1e-3;
 if (u=="Mpc") val=dist;
 if (u=="pc") val=dist*1e6;
 if (u=="ly") val=dist*3.26156e6;
 if (u=="m") val=distm;
 if (u=="km") val=distm*1e-3;
 if (u=="cm") val=distm*1e2;
 
 return val;
}

Double_t NcAstrolab::GetLightTravelTime(Double_t z) const
{
 
 Double_t val=GetLightTravelDistance(z,"ly");
 
 return val;
}

Double_t NcAstrolab::GetHubbleParameter(Double_t z,TString u) const
{
 
 if (z<0 || fHubble<=0) return 0;
 
 TF1 f("f","sqrt([0]*pow((1.+x),4)+[1]*pow((1.+x),3)+[2])");
 
 f.SetParameter(0,fOmegaR);
 f.SetParameter(1,fOmegaM);
 f.SetParameter(2,fOmegaL);
 f.SetRange(0,z);
 
 Double_t H=f.Eval(z);
 H*=fHubble; // The current Hubble parameter (H0) in km/s per Mpc
 
 Double_t Hm=H/(1e6*fPc); // corresponding H in km/s per meter
 
 Double_t val=0;
 
 if (u=="Gpc") val=H/1e-3;
 if (u=="Mpc") val=H;
 if (u=="pc") val=H/1e6;
 if (u=="ly") val=H/3.26156e6;
 if (u=="m") val=Hm;
 if (u=="km") val=Hm/1e-3;
 if (u=="cm") val=Hm/1e2;
 
 return val;
}

Double_t NcAstrolab::GetNuclearMass(Int_t Z,Int_t N,Int_t mode) const
{
 
 if (Z<0 || N<0) return 0;
 
 Double_t rz=Z;
 Double_t rn=N;
 Double_t ra=Z+N;
 
 // Coefficients from a recent fit mentioned in Tipler's modern physics (4th ed.) textbook.
 // The values in the comment field are the ones of the slides mentioned above.
 Double_t a=15.67;  //15.835;
 Double_t b=17.23;  //18.33;
 Double_t s=23.2;   //23.20;
 Double_t d=0.75;   //0.714;
 Double_t delta=12; //11.2;
 
 Double_t term1=a*ra;                       // Constant bulk binding energy like cohesion in a liquid
 Double_t term2=b*pow(ra,2./3.);            // Surface energy of a sphere like surface tension of liquids
 Double_t term3=s*pow((rn-rz),2.)/ra;       // Symmetry term
 Double_t term4=d*pow(rz,2.)/pow(ra,1./3.); // Coulomb term
 Double_t term5=0;                          // Phenomenological correction for light nuclei (pairing energy term)
 
 Int_t oz=Z%2; // Flag (1) for odd Z nuclei 
 Int_t on=N%2; // Flag (1) for odd N nuclei
 
 if (oz && on) term5=delta/sqrt(ra);
 if (!oz && !on) term5=-delta/sqrt(ra);
 
 // Binding energy in MeV
 Double_t bnz=term1-term2-term3-term4-term5;
 
 // In case a single nucleon was specified
 if ((Z+N)<2)
 {
  bnz=0;
  ra=1;
 }
 
 // Nuclear mass in MeV/c^2
 Double_t mass=rz*fMp+rn*fMn-bnz;
 
 // Explicit literature values for very light elements
 if (Z==1 && N==1) // Deuteron
 {
  mass=2.013553212712*fAmu;
  bnz=rz*fMp+rn*fMn-mass;
 }
 
 if (Z==1 && N==2) // Triton
 {
  mass=3.0155007134*fAmu;
  bnz=rz*fMp+rn*fMn-mass;
 }
 
 if (Z==2 && N==1) // Helion
 {
  mass=3.0149322468*fAmu;
  bnz=rz*fMp+rn*fMn-mass;
 }
 
 if (Z==2 && N==2) // Alpha
 {
  mass=4.001506179125*fAmu;
  bnz=rz*fMp+rn*fMn-mass;
 }
 
 Double_t value=0;
 
 switch(mode)
 {
  case 1 : // Nuclear mass in GeV/c^2
   value=mass/1000.;
   break;
 
  case -1 : // Nuclear mass in amu
   value=mass/fAmu;
   break;
 
  case 2 : // Total binding energy in MeV
   value=bnz;
   break;
 
  case -2 : // Total binding energy in amu
   value=bnz/fAmu;
   break;
 
  case 3 : // Binding energy per nucleon in MeV
   value=bnz/ra;
   break;
 
  case -3 : // Binding energy per nucleon in amu
   value=bnz/(fAmu*ra);
   break;
 }
 
 return value;
}

Double_t NcAstrolab::GetRadiationLength(Double_t Z,Double_t A,Double_t rho) const
{
 
 Double_t X0=-1;
 
 if (Z<=0 || A<1 || A<Z) return -1;
 
 X0=716.4*A/(Z*(Z+1.)*(log(287./sqrt(Z))));
 
 Double_t mN=0.001*fGn*fQe/fAmu; // The nucleon mass in gram
 if (rho==0) X0=X0/mN;
 if (rho>0) X0=X0/rho;
 
 return X0;
}

Double_t NcAstrolab::GetMeanFreePath(Double_t sigma,Double_t rho,Int_t mode) const
{
 
 Double_t lambda=-1;
 
 if (sigma<=0 || rho<=0 || mode<0 || mode>4) return -1;
 
 Double_t mN=0.001*fGn*fQe/fAmu; // The nucleon mass in gram
 Double_t n=fabs(rho)/mN;        // The number of nucleons per cm^3
 if (mode<2) n=rho;              // The number of scattering centers per cm^3
 sigma=sigma*1e-24;              // Convert to cm^2
 
 lambda=1./(sigma*n);
 
 if (mode==1 || mode==4) lambda=lambda*n;
 if (mode==3) lambda=lambda*rho;
 
 return lambda;
}

Double_t NcAstrolab::GetInteractionProbability(Double_t x,Double_t lambda) const
{
 
 Double_t prob=-1;
 
 if (x<0 || lambda<=0) return -1;
 
 prob=1.-exp(-x/lambda);
 
 return prob;
}

Double_t NcAstrolab::GetInteractionProbability(Double_t x,Double_t sigma,Double_t rho,Int_t mode) const
{
 
 Double_t prob=-1;
 
 Double_t lambda=GetMeanFreePath(sigma,rho,mode);
 
 if (lambda>0) prob=GetInteractionProbability(x,lambda);
 
 return prob;
}

Double_t NcAstrolab::GetSurvivalProbability(Double_t x,Double_t lambda) const
{
 
 Double_t prob=-1;
 
 if (x<0 || lambda<=0) return -1;
 
 prob=exp(-x/lambda);
 
 return prob;
}

Double_t NcAstrolab::GetSurvivalProbability(Double_t x,Double_t sigma,Double_t rho,Int_t mode) const
{
 
 Double_t prob=-1;
 
 Double_t lambda=GetMeanFreePath(sigma,rho,mode);
 
 if (lambda>0) prob=GetSurvivalProbability(x,lambda);
 
 return prob;
}

Double_t NcAstrolab::GetShieldingThickness(Double_t prob,Double_t lambda) const
{
 
 Double_t x=-1;
 
 if (prob<=0 || prob>1 || lambda<=0) return -1;
 
 x=-lambda*log(prob);
 
 return x;
}

Double_t NcAstrolab::GetShieldingThickness(Double_t prob,Double_t sigma,Double_t rho,Int_t mode) const
{
 
 Double_t x=-1;
 
 if (prob<=0 || prob>1) return -1;
 
 Double_t lambda=GetMeanFreePath(sigma,rho,mode);
 
 if (lambda>0) x=GetShieldingThickness(prob,lambda);
 
 return x;
}

Double_t NcAstrolab::GetTargetThickness(Double_t prob,Double_t lambda) const
{
 
 if (prob<=0 || prob>1 || lambda<=0) return -1;
 
 Double_t p=1.-prob;
 Double_t x=GetShieldingThickness(p,lambda);
 
 return x;
}

Double_t NcAstrolab::GetTargetThickness(Double_t prob,Double_t sigma,Double_t rho,Int_t mode) const
{
 
 Double_t x=-1;
 
 if (prob<=0 || prob>1) return -1;
 
 Double_t lambda=GetMeanFreePath(sigma,rho,mode);
 
 Double_t p=1.-prob;
 if (lambda>0) x=GetShieldingThickness(p,lambda);
 
 return x;
}

Double_t NcAstrolab::GetNeutrinoXsection(Int_t mode,Int_t type,Double_t egev,Double_t xscale,Double_t* eprimgev,Double_t* alpha) const
{
 
 if (eprimgev) *eprimgev=0;
 if (alpha) *alpha=0;
 if (!mode || mode>3 || mode<-4 || !type || abs(type)>3) return 0;
 
 const Double_t fnumuccn=6.77e-15;             // Nu_mu+Nucleon CC sigma/E in barn/GeV
 const Double_t fanumuccn=3.34e-15;            // Anti-Nu_mu+Nucleon CC sigma/E in barn/GeV
 
 const Double_t sinw2=GetPhysicalParameter("Sin2w"); // sin^2 of the Weinberg angle
 
 const Double_t fnuetote=0.25+sinw2+4.*pow(sinw2,2.)/3.;           // Nu_e+e total sigma/sigma0
 const Double_t fanuetote=(1./12.)+(sinw2/3.)+4.*pow(sinw2,2.)/3.; // Anti-Nu_e+e total sigma/sigma0
 Double_t fnumucce=1.;                                             // Nu_mu+e CC sigma/sigma0
 const Double_t fnumunce=0.25-sinw2+4.*pow(sinw2,2.)/3.;           // Nu_mu+e NC sigma/sigma0
 const Double_t fanumunce=(1./12.)-(sinw2/3.)+4.*pow(sinw2,2.)/3.; // Anti-Nu_mu+e NC sigma/sigma0
 const Double_t f4=1./3.;                                          // Anti-Nu_e+e-->Anti-Nu_mu+mu CC sigma/sigma0
 
 // Parameters for the (anti)neutrino+Nucleon cross section parametrisations of Conolly et al.
 const Double_t c0nu=-1.826;
 const Double_t c1nu=-17.31;
 const Double_t c2nunc=-6.448;
 const Double_t c2nucc=-6.406;
 const Double_t c3nu=1.431;
 const Double_t c4nunc=-18.61;
 const Double_t c4nucc=-17.91;
 const Double_t c0anu=-1.033;
 const Double_t c1anu=-15.95;
 const Double_t c2anunc=-7.296;
 const Double_t c2anucc=-7.247;
 const Double_t c3anu=1.569;
 const Double_t c4anunc=-18.30;
 const Double_t c4anucc=-17.72;
 
 Double_t rncnu=0.2261/0.7221;  // sigma_nc/sigma_cc for Neutrino+Nucleon DIS at 100 GeV
 Double_t rncanu=0.1307/0.3747; // sigma_nc/sigma_cc for Anti-neutrino+Nucleon DIS at 100 GeV
 
 // Average inelasticity (y) values from Gandhi et al.
 Double_t ynucc[12]={0.483,0.477,0.472,0.426,0.332,0.237,0.250,0.237,0.225,0.216,0.208,0.205};
 Double_t ynunc[12]={0.474,0.470,0.467,0.428,0.341,0.279,0.254,0.239,0.227,0.217,0.210,0.207};
 Double_t yanucc[12]={0.333,0.340,0.354,0.345,0.301,0.266,0.249,0.237,0.225,0.216,0.208,0.205};
 Double_t yanunc[12]={0.350,0.354,0.368,0.358,0.313,0.273,0.253,0.239,0.227,0.217,0.210,0.207};
 
 Double_t loge=log10(egev);
 Double_t y=0;
 Int_t index=int(loge+0.5);
 if (index<1) index=1;
 if (index>12) index=12;
 if (eprimgev)
 {
  if (type>0) // Neutrinos
  {
   if (abs(mode)==1) y=ynucc[index-1];
   if (abs(mode)==2) y=ynunc[index-1];
   if (mode==3) y=(ynucc[index-1]+rncnu*ynunc[index-1])/(1.+rncnu);
   if (mode==-3) y=(ynucc[index-1]+fnumunce*ynunc[index-1])/(1.+fnumunce);
  }
  else // Anti-neutrinos
  {
   if (abs(mode)==1) y=yanucc[index-1];
   if (abs(mode)==2) y=yanunc[index-1];
   if (mode==3) y=(yanucc[index-1]+rncanu*yanunc[index-1])/(1.+rncanu);
   if (mode==-3) y=(yanucc[index-1]+fnumunce*yanunc[index-1])/(1.+fnumunce);
  }
  *eprimgev=egev*(1.-y);
 }
 
 if (alpha)
 {
  Double_t mtarg=fMe;
  if (mode>0) mtarg=GetPhysicalParameter("Mnucl");
  *alpha=sqrt(2.e-3*mtarg/egev)*y*180./((1.-y)*acos(-1.));
 }
 
 Double_t xsec=0;
 Double_t fact=0;
 Double_t c0=0,c1=0,c2=0,c3=0,c4=0;
 
 if (mode>0) // DIS on Nucleon target
 {
  if (mode==3) // Total xsec
  {
   // Recursive invokation for NC+CC cross section
   xsec=GetNeutrinoXsection(1,type,egev,xscale);
   xsec+=GetNeutrinoXsection(2,type,egev,xscale);
   return xsec;
  }
  if (egev<1e4) // Energy below 10 TeV
  {
   if (mode==1) // CC xsec
   {
    fact=fnumuccn;
    if (type<0) fact=fanumuccn;
   }
   if (mode==2) // NC xsec
   {
    fact=fnumuccn*rncnu;
    if (type<0) fact=fanumuccn*rncanu;
   }
   xsec=fact*egev;
  }
  else // Energy of 10 TeV and above
  {
   if (mode==1) // CC xsec
   {
    if (type>0)
    {
     c0=c0nu;
     c1=c1nu;
     c2=c2nucc;
     c3=c3nu;
     c4=c4nucc;
    }
    else
    {
     c0=c0anu;
     c1=c1anu;
     c2=c2anucc;
     c3=c3anu;
     c4=c4anucc;
    }
   }
   if (mode==2) // NC xsec
   {
    if (type>0)
    {
     c0=c0nu;
     c1=c1nu;
     c2=c2nunc;
     c3=c3nu;
     c4=c4nunc;
    }
    else
    {
     c0=c0anu;
     c1=c1anu;
     c2=c2anunc;
     c3=c3anu;
     c4=c4anunc;
    }
   }
   Double_t lne=log(loge-c0);
   Double_t logsigma=c1+c2*lne+c3*pow(lne,2.)+c4/lne; // Log10(sigma) in cm^2
   logsigma+=24.;
   xsec=pow(10.,logsigma);
  }
 }
 else // Scattering on electron target
 {
  // Check whether we are in the Glashow resonance regime
  Double_t elow=pow((fMW-2.*fGammaW),2.)/(2.e-3*fMe);  
  Double_t eup=pow((fMW+2.*fGammaW),2.)/(2.e-3*fMe);
  if (mode==-3 && type==-1 && egev>elow && egev<eup) // Total xsec at Glashow resonance
  {
   xsec=5.02e-7/xscale;
   if (eprimgev) *eprimgev=0;
   if (alpha) *alpha=0;
   return xsec;
  }
 
  // Check if we are above the kinematical threshold energy for CC scattering
  Double_t mlepton=fMe;
  if (abs(type)==2) mlepton=fMmu;
  if (abs(type)==3) mlepton=fMtau;
  Double_t eth=1.e-3*(pow(mlepton,2.)-pow(fMe,2.))/(2.*fMe);
 
  if (egev<eth) // Below CC kinematical threshold 
  {
   fnumucce=0;
   if (mode==-1) // CC xsec was requested
   {
    if (eprimgev) *eprimgev=egev;
    if (alpha) *alpha=0;
    return 0;
   }
  }
 
  // The Nu_mu+e CC cross section in barn well above threshold
  Double_t sigma0=pow(fFermi,2.)*fHbarc2*2.e-3*fMe*egev/acos(-1.);
 
  if (mode==-1) // CC xsec
  {
   if (type>1) fact=fnumucce;
  }
  if (mode==-2) // NC xsec
  {
   if (type>1) fact=fnumunce;
   if (type<-1) fact=fanumunce;
  }
  if (mode==-3) // Total xsec
  {
   if (type==1) fact=fnuetote;
   if (type==-1) fact=fanuetote;
   if (type>1) fact=fnumucce+fnumunce;
   if (type<-1) fact=fanumunce;
  }
  if (mode==-4 && type==-1) fact=f4;
  xsec=fact*sigma0;
 }
 
 xsec/=xscale;
 
 return xsec;
}

Double_t NcAstrolab::GetNeutrinoAngle(Double_t E,TString u,Int_t mode,TF1* f)
{
 
 Double_t value=-1;
 
 if (E<=0 || mode<0 || mode>2) return value;
 
 // Convert to TeV
 E*=0.001;
 
 // The parametrisation (in degrees) for a 1 TeV neutrino
 Double_t mean=1.38711583;
 Double_t median=0.86842105;
 Double_t mpv=0.560150;
 Double_t sigma=0.226679;
 
 // Scaling the parameters to the provided neutrino energy
 Double_t p=log10(E);
 Double_t scale=1./(pow(1.5,p)*sqrt(E));
 
 mean*=scale;
 median*=scale;
 mpv*=scale;
 sigma*=scale;
 
 // Create a normalized Landau distribution template
 if (!fNuAngle)
 {
  fNuAngle=new TF1("NuAngle","TMath::Landau(x,[0],[1],1)",0,90);
  fNuAngle->SetTitle("Landau pdf;Neutrino-lepton opening angle in degrees;PDF");
 }
 
 // Set the parameters for the Landau parametrization
 fNuAngle->SetParameter(0,mpv);
 fNuAngle->SetParameter(1,sigma);
 
 // Obtain an opening angle value according to the pdf
 Double_t ang=fNuAngle->GetRandom();
 
 if (u=="rad")
 {
  Double_t fact=acos(-1.)/180.; // Coversion factor degrees->radians
  mean*=fact;
  median*=fact;
  ang*=fact;
 }
 
 // Provide the used pdf if requested
 if (f) fNuAngle->Copy(*f);
 
 value=mean;
 if (mode==1) value=median;
 if (mode==2) value=ang;
 
 return value;
}

void NcAstrolab::RandomPosition(Nc3Vector& v,Double_t thetamin,Double_t thetamax,Double_t phimin,Double_t phimax)
{
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // with identical measurements and reference signals without explicit initialisation
 // of the randomiser by the user at the start of the analysis.
 if (!fRan) fRan=new NcRandom(-1);
 
 // Generate random angles in the specified range
 Double_t pi=acos(-1.);
 Double_t cosmax=cos(thetamin*pi/180.);
 Double_t cosmin=cos(thetamax*pi/180.);
 Double_t cost=fRan->Uniform(cosmin,cosmax);
 Double_t theta=acos(cost)*180./pi;
 Double_t phi=fRan->Uniform(phimin,phimax);
 
 Double_t norm=1;
 if (v.HasVector()) norm=v.GetNorm();
 
 Double_t err[3]={0,0,0};
 Int_t ier=0;
 if (v.HasErrors())
 {
  ier=1;
  v.GetErrors(err,"car");
 }
 
 v.SetVector(norm,theta,phi,"sph","deg");
 if (ier) v.SetErrors(err,"car");
}

void NcAstrolab::SmearPosition(Nc3Vector& v,Double_t sigma)
{
 
 if (!v.HasVector()) return;
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // with identical measurements and reference signals without explicit initialisation
 // of the randomiser by the user at the start of the analysis.
 if (!fRan) fRan=new NcRandom(-1);
 
 Double_t norm=v.GetX(1,"sph","deg");
 Double_t theta=v.GetX(2,"sph","deg");
 Double_t phi=v.GetX(3,"sph","deg");
 Double_t err[3]={0,0,0};
 Int_t ier=0;
 if (v.HasErrors())
 {
  ier=1;
  v.GetErrors(err,"car");
 }
 if (norm<=0)
 {
  norm=1;
  err[0]=0;
 }
 v.SetVector(norm,theta,phi,"sph","deg");
 
 // The smeared position will be generated as if the actual vector "v" coincided with the positive Z-axis.
 // The actual smeared position will be obtained via a "backward rotation" to the real frame orientation.
 
 // Determine the rotation matrix for the frame in which "v" coincides with the positive Z-axis.
 TRotMatrix m;
 m.SetAngles(90.+theta,phi,90,phi+90.,theta,phi);
 
 // Generate smeared position w.r.t. the fictative Z-axis 
 Double_t pi=acos(-1.);
 Double_t cosmax=1;
 Double_t cosmin=cos(fabs(sigma)*pi/180.);
 Double_t phimin=0;
 Double_t phimax=360;
 Double_t cost=0;
 if (sigma<0)
 {
  cost=fRan->Uniform(cosmin,cosmax);
  theta=acos(cost)*180./pi;
 }
 else
 {
  theta=fRan->Gauss(0.,sigma);
 }
 phi=fRan->Uniform(phimin,phimax);
 
 // Enter the "fake" smeared position into vector "v".
 v.SetVector(norm,theta,phi,"sph","deg");
 
 // Invoke the inverse rotation to obtain the actual smeared position.
 v=v.GetUnprimed(&m);
 if (ier) v.SetErrors(err,"car");
}

void NcAstrolab::ShiftPosition(Nc3Vector& v,Double_t angle)
{
 
 if (!v.HasVector()) return;
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // under identical conditions without explicit initialisation of the randomiser
 // by the user at the start of the analysis.
 if (!fRan) fRan=new NcRandom(-1);
 
 Double_t norm=v.GetX(1,"sph","deg");
 Double_t theta=v.GetX(2,"sph","deg");
 Double_t phi=v.GetX(3,"sph","deg");
 Double_t err[3]={0,0,0};
 Int_t ier=0;
 if (v.HasErrors())
 {
  ier=1;
  v.GetErrors(err,"car");
 }
 if (norm<=0)
 {
  norm=1;
  err[0]=0;
 }
 v.SetVector(norm,theta,phi,"sph","deg");
 
 // The shifted position will be generated as if the actual vector "v" coincided with the positive Z-axis.
 // The actual shifted position will be obtained via a "backward rotation" to the real frame orientation.
 
 // Determine the rotation matrix for the frame in which "v" coincides with the positive Z-axis.
 TRotMatrix m;
 m.SetAngles(90.+theta,phi,90,phi+90.,theta,phi);
 
 // Generate the shifted position w.r.t. the fictative Z-axis 
 Double_t phimin=0;
 Double_t phimax=360;
 theta=angle;
 phi=fRan->Uniform(phimin,phimax);
 
 // Enter the "fake" shifted position into vector "v".
 v.SetVector(norm,theta,phi,"sph","deg");
 
 // Invoke the inverse rotation to obtain the actual shifted position.
 v=v.GetUnprimed(&m);
 if (ier) v.SetErrors(err,"car");
}

TH1F NcAstrolab::GetDxHistogram(TH1* hx,Int_t nc,Double_t dxbin,Double_t dxmin,Double_t dxmax,Int_t mode,Double_t fact)
{
 
 TH1F hdx;
 
 if (mode<0 || mode>3) return hdx;
 
 if (!hx) return hdx;
 
 if (nc<1) return hdx;
 
 Int_t nenhx=hx->GetEntries();
 if (nenhx<=nc) return hdx;
 
 Int_t idxbin=TMath::Nint(dxbin);
 if (idxbin<-2) return hdx;
 
 // Create the output histogram if all parameters have been specified or determined automatically.
 // If not, this will be done at a recursive invokation (see below) once (some of) the
 // parameters have been determined automatically from the input histogram.
 if (dxmin>=0 && dxmax>=dxmin && dxbin>0)
 {
  Int_t nbins=1;
  Double_t range=dxmax-dxmin;
  if (range>dxbin) nbins=TMath::Nint(range/dxbin);
  hdx.SetBins(nbins,dxmin,dxmax);
 
  // Add histogram and axes titles
  TString s;
  Double_t binwidth=hdx.GetXaxis()->GetBinWidth(1);
  s.Form("Dx interval distribution between %-i consecutive entries (nc=%-i, mode=%-i);Dx interval;Counts per bin of size %-.3g",nc+1,nc,mode,binwidth);
  hdx.SetNameTitle("DxHistogram",s);
 }
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // under identical conditions without explicit initialisation of the randomiser
 // by the user at the start of the analysis.
 if (!fRan) fRan=new NcRandom(-1);
 
 // Determine the minimum and maximum encountered dx or fill the output histogram
 Double_t x1,x2,deltax;
 Int_t nx1,nx2;
 Double_t deltaxmin=0;
 Double_t deltaxmax=0;
 Bool_t found=kFALSE;
 Int_t ndxcount=0;
 Int_t jstart;
 
 Int_t nbhx=hx->GetNbinsX();
 Double_t value=0;
 Double_t xlow=0;
 Double_t xup=0;
 Double_t bsize=0;
 for (Int_t i=1; i<=nbhx; i++)
 {
  deltax=-1;
  ndxcount=0;
  xlow=hx->GetBinLowEdge(i);
  bsize=hx->GetBinWidth(i);
  xup=xlow+bsize;
  x1=hx->GetBinCenter(i);
  if (mode==1 || mode==3) x1=fRan->Uniform(xlow,xup);
  value=hx->GetBinContent(i);
  nx1=0;
  if (value) nx1=1;
  if (mode<2) nx1=TMath::Nint(value);
 
  while (nx1>0)
  {
   // Check for multiple counts (left) in this bin
   jstart=i+1;
   if (nx1>1) jstart=i;
 
   for (Int_t j=jstart; j<=nbhx; j++)
   {
    xlow=hx->GetBinLowEdge(j);
    bsize=hx->GetBinWidth(j);
    xup=xlow+bsize;
    x2=hx->GetBinCenter(j);
    if (mode==1 || mode==3) x2=fRan->Uniform(xlow,xup);
    value=hx->GetBinContent(j);
    nx2=0;
    if (value) nx2=1;
    if (mode<2) nx2=TMath::Nint(value);
 
    if (j==i) nx2=nx1-1; // Counting within the same bin
 
    // Empty bin
    if (nx2<1) continue;
 
    ndxcount+=nx2;
 
    if (ndxcount>=nc)
    {
     deltax=fabs(x2-x1);
     if (dxmin>=0 && dxmax>=dxmin && dxbin>0) // Output histogram has been initialised
     {
      hdx.Fill(deltax);
     }
     else // Auto-determination of the output histogram range
     {
       if (!found || deltax<deltaxmin) deltaxmin=deltax;
       if (!found || deltax>deltaxmax) deltaxmax=deltax;
     }
     ndxcount=0;
     found=kTRUE;
     break;
    }
   }
   nx1--;
  }
 }
 
 // Check if a suitable configuration of entries was encountered
 if (!found) return hdx;
 
 // Check if a recursive call is needed to actually create and fill the output histogram
 Int_t nen=hdx.GetEntries();
 if (!nen)
 {
  // Set the bin size (if needed) for the output histogram
  if (!idxbin && dxbin<=0) dxbin=hx->GetBinWidth(1);
  if (idxbin==-1)
  {
   dxbin=(hx->GetBinWidth(1))*fact;
   if (deltaxmin>0 && deltaxmin>dxbin) dxbin=deltaxmin;
   if (dxbin<=0) dxbin=hx->GetBinWidth(1);
  }
  if (idxbin==-2)
  {
   dxbin=hx->GetBinWidth(1);
   dxbin=dxbin*float(nc);
  }
 
  // Set the auto-determined range of the output histogram
  if (dxmin<0)
  {
   dxmin=deltaxmin;
   // Compensate for randomized x-values within the input histogram bins
   if (mode==1 || mode==3)
   {
    bsize=hx->GetBinWidth(1);
    dxmin=dxmin-2.*bsize;
    if (dxmin<0) dxmin=0;
   }
  }
  if (dxmax<0)
  {
   dxmax=deltaxmax+dxbin;
   // Compensate for randomized x-values within the input histogram bins
   if (mode==1 || mode==3)
   {
    bsize=hx->GetBinWidth(1);
    dxmax=dxmax+2.*bsize;
   }
  }
 
  // Invoke the recursive call to create and fill the output histogram
  hdx=GetDxHistogram(hx,nc,dxbin,dxmin,dxmax,mode,fact);
 }
 
 return hdx;
}

TH1F NcAstrolab::GetDifHistogram(TH1* hin,Int_t mode,TString s,TF1* f) const
{
 
 TH1F hout;
 
 if (!hin) return hout;
 
 Int_t nbins=hin->GetNbinsX();
 if (!nbins) return hout;
 
 // Set the X-axis parameters identical to the input histogram
 const TArrayD* xarr=hin->GetXaxis()->GetXbins();
 Int_t xsize=xarr->GetSize();
 if (!xsize)
 {
  Double_t xmin=hin->GetXaxis()->GetXmin();
  Double_t xmax=hin->GetXaxis()->GetXmax();
  hout.SetBins(nbins,xmin,xmax);
 }
 else
 {
  const Double_t* xbins=xarr->GetArray();
  hout.SetBins(nbins,xbins);
 }
 
 // Set histogram title
 hout.SetNameTitle("DifHistogram",hin->GetTitle());
 
 // Set axes titles
 TString sxin=hin->GetXaxis()->GetTitle();
 TString syin=hin->GetYaxis()->GetTitle();
 
 TString sxout=sxin;
 
 TString syout=s;
 if (syout=="")
 {
  if (f)
  {
   syout=f->GetExpFormula("p");
   syout+="*";
  }
  syout+="d(";
  syout+=syin;
  syout+=")/d(";
 
  // Remove Log indication from the "hin" X-axis title
  // to get a proper dy/dx label for the "hout" Y-axis
  if (mode)
  {
   sxin.ReplaceAll("^{10}log","");
   sxin.ReplaceAll("^{10}Log","");
   sxin.ReplaceAll("log10","");
   sxin.ReplaceAll("Log10","");
   sxin.ReplaceAll("log","");
   sxin.ReplaceAll("Log","");
   sxin.ReplaceAll("ln","");
   sxin.ReplaceAll("Ln","");
  }
 
  syout+=sxin;
  syout+=")";
  syout.ReplaceAll("((","(");
  syout.ReplaceAll("))",")");
 }
 
 hout.GetXaxis()->SetTitle(sxout.Data());
 hout.GetYaxis()->SetTitle(syout.Data());
 
 // Determine the new Y-values and fill the output histogram
 Double_t x=0;
 Double_t y=0;
 Double_t err=0;
 Double_t width=0;
 Double_t binlow=0;
 Double_t binup=0;
 Double_t scale=0;
 for (Int_t i=1; i<=nbins; i++)
 {
  x=hin->GetBinCenter(i);
  y=hin->GetBinContent(i);
  err=fabs(hin->GetBinError(i));
  width=hin->GetBinWidth(i);
  binlow=hin->GetBinLowEdge(i);
  binup=binlow+width;
 
  // Check if the binwidth is physical
  if (width<=0) continue;
 
  // Correct for log-scale annotation on X-axis
  if (mode==1)
  {
   x=pow(10.,x);
   width=pow(10.,binup)-pow(10.,binlow);
  }
  if (mode==2)
  {
   x=exp(x);
   width=exp(binup)-exp(binlow);
  }
 
  y=y/width;
  err=err/width;
 
  // Rescale via the function "f" if provided
  if (f)
  {
   scale=f->Eval(x);
   y=y*scale;
   err=err*scale;
  }
 
  hout.SetBinContent(i,y);
  hout.SetBinError(i,err);
 }
 
 return hout;
}

TH1F NcAstrolab::GetCountsHistogram(TF1& spec,Int_t nbins,Double_t xmin,Double_t xmax,Int_t mode,TString s) const
{
 
 // Setting up the output histogram
 TH1F hout;
 hout.SetName("CountsHistogram");
 
 // Set histogram title and axes labels
 if (s=="")
 {
  s="CountsHistogram;";
  if (mode==1)
  {
   s+="^{10}Log(";
  }
  else if (mode==2)
  {
   s+="Ln(";
  }
  s+=spec.GetXaxis()->GetTitle();
  if (mode) s+=")";
  s+=";Counts";
 }
 hout.SetTitle(s.Data());
 
 // Setting histogram binning 
 Double_t step=(xmax-xmin)/double(nbins);
 Double_t* xbins=new Double_t[nbins+1];
 Double_t x=xmin;
 for (Int_t ibin=0; ibin<=nbins; ibin++)
 {
  xbins[ibin]=x;
  x=x+step;
 }
 
 hout.SetBins(nbins,xbins);
 
 // Filling the output histogram
 Double_t xval=0;
 Double_t dx=0;
 Double_t N=0;
 x=xmin;
 for (Int_t ibin=1; ibin<=nbins; ibin++)
 {
  if (!mode)
  {
   xval=x;
   dx=xbins[ibin]-xbins[ibin-1];
   N=spec.Eval(x)*dx;
  }
  else if (mode==1)
  {
   xval=pow(10.,x);
   dx=pow(10.,xbins[ibin])-pow(10.,xbins[ibin-1]);
   N=spec.Eval(xval)*dx;
  }
  else if (mode==2)
  {
   xval=exp(x);
   dx=exp(xbins[ibin])-exp(xbins[ibin-1]);
   N=spec.Eval(xval)*dx;
  }
  hout.Fill(x,N);
  x=x+step;
 }
 
 delete [] xbins;
 
 return hout;
}

TH1F NcAstrolab::GetCountsHistogram(TH1& hin,Int_t mode,TString s,TF1* fscale) const
{
 
 // Setting up the output histogram
 TH1F hout;
 hout.SetName("CountsHistogram");
 Int_t nbins=hin.GetNbinsX();
 
 if (nbins<1) return hout;
 
 TAxis* ax=hin.GetXaxis();
 Double_t xmin=ax->GetXmin();
 Double_t xmax=ax->GetXmax();
 hout.SetBins(nbins,xmin,xmax);
 
 // Set histogram title and axes labels
 if (s=="")
 {
  s=hin.GetTitle();
  s+=";";
  TString tx=ax->GetTitle();
  if (tx!="")
  {
   s+=tx;
  }
  else
  {
   if (mode==0) s+="x";
   if (mode==1) s+="^{10}Log(x)";
   if (mode==2) s+="Ln(x)";
  }
  s+=";Counts";
 }
 hout.SetTitle(s);
 
 // Filling the output histogram
 Double_t x=0;
 Double_t xlow=0;
 Double_t xup=0;
 Double_t dx=0;
 Double_t xval=0;
 Double_t N=0;
 Double_t fval=0;
 for (Int_t ibin=1; ibin<=nbins; ibin++)
 {
  x=hin.GetBinCenter(ibin);
  xlow=hin.GetBinLowEdge(ibin);
  xup=xlow+hin.GetBinWidth(ibin);
  N=hin.GetBinContent(ibin);
  if (!mode)
  {
   xval=x;
   dx=xup-xlow;
   N=N*dx;
  }
  else if (mode==1)
  {
   xval=pow(10.,x);
   dx=pow(10.,xup)-pow(10.,xlow);
   N=N*dx;
  }
  else if (mode==2)
  {
   xval=exp(x);
   dx=exp(xup)-exp(xlow);
   N=N*dx;
  }
 
  // Compensate for the Y-axis scaling if needed
  if (fscale)
  {
   fval=fscale->Eval(xval);
   if (fval) N=N/fval;
  }
 
  hout.Fill(x,N);
 }
 
 return hout;
}

TH1F NcAstrolab::GetLogHistogram(TH1* hin,Int_t mode,TString s) const
{
 
 TH1F hout;
 
 if (!hin || mode<1 || mode>2) return hout;
 
 Int_t nbins=hin->GetNbinsX();
 if (!nbins) return hout;
 
 // Set the X-axis parameters identical to the input histogram
 const TArrayD* xarr=hin->GetXaxis()->GetXbins();
 Int_t xsize=xarr->GetSize();
 if (!xsize)
 {
  Double_t xmin=hin->GetXaxis()->GetXmin();
  Double_t xmax=hin->GetXaxis()->GetXmax();
  hout.SetBins(nbins,xmin,xmax);
 }
 else
 {
  const Double_t* xbins=xarr->GetArray();
  hout.SetBins(nbins,xbins);
 }
 
 // Set histogram and axes titles
 hout.SetNameTitle("LogHistogram",hin->GetTitle());
 
 if (s=="")
 {
  s="^{10}Log(";
  if (mode==2) s="Ln(";
  s+=hin->GetYaxis()->GetTitle();
  s+=")";
 }
 
 hout.GetXaxis()->SetTitle(hin->GetXaxis()->GetTitle());
 hout.GetYaxis()->SetTitle(s.Data());
 
 // Determine the new Y-values and fill the output histogram
 Double_t y=0;
 Double_t err=0;
 Double_t yplus=0;
 for (Int_t i=1; i<=nbins; i++)
 {
  y=hin->GetBinContent(i);
  err=fabs(hin->GetBinError(i));
  yplus=y+err;
 
  // Check if Log10(y) or Ln(y) is defined
  if (y<=0) continue;
 
  if (mode==1)
  {
   y=log10(y);
   yplus=log10(yplus);
  }
  else
  {
   y=log(y);
   yplus=log(yplus);
  }
 
  hout.SetBinContent(i,y);
  err=fabs(yplus-y);
  hout.SetBinError(i,err);
 }
 
 return hout;
}

Double_t NcAstrolab::GetBackgroundRateProb(Double_t* vars,Double_t* pars)
{
 
 Double_t b=vars[0];
 Int_t Noff=int(pars[0]);
 Double_t Toff=pars[1];
 Double_t bmax=pars[2];
 Double_t prec=pars[3];
 
 if (b<=0 || Noff<0 || Toff<=0) return 0;
 
 Double_t rNoff=Noff;
 if (bmax<0) bmax=100.*rNoff/Toff;
 
 NcMath math;
 
 Double_t lnU=0;
 Double_t lnD=0;
 Double_t lnprob=0;
 Double_t prob=0;
 
 // The ln of the numerator of Eq.(15) of the publication mentioned above
 lnU=log(Toff)+rNoff*log(b*Toff)-b*Toff;
 
 // The ln of the denominator of eq.(15) of the publication mentioned above
 lnD=math.LnGamma(Noff+1,bmax*Toff,1);
 
 lnprob=lnU-lnD;
 
 if (lnprob < -fabs(prec)) return 0;
 
 if (lnprob > fabs(prec)) lnprob=fabs(prec);
 prob=exp(lnprob);
 
 return prob;
}

Double_t NcAstrolab::GetSignalRateProb(Double_t* vars,Double_t* pars)
{
 
 Double_t s=vars[0];
 Int_t Non=TMath::Nint(pars[0]);
 Double_t Ton=pars[1];
 Int_t Noff=TMath::Nint(pars[2]);
 Double_t Toff=pars[3];
 Double_t smax=pars[4];
 Double_t bmax=pars[5];
 Double_t prec=pars[6];
 
 if (s<0 || Non<0 || Ton<=0 || Noff<0 || Toff<=0) return 0;
 
 Double_t rNon=Non;
 if (smax<0) smax=100.*rNon/Ton;
 
 Double_t rNoff=Noff;
 if (bmax<0) bmax=100.*rNoff/Toff;
 
 NcMath math;
 
 //Store factorials in an array to decrease the processing time
 Int_t ndim=Non+Noff+1;
 TArrayD lnfacN(ndim);
 
 lnfacN[0]=0;
 Double_t x=0;
 for (Int_t i=1; i<ndim; i++)
 {
  x+=log(double(i));
  lnfacN[i]=x;
 }
 
 Double_t lnU=0;
 Double_t lnD=0;
 Double_t sumU=0;
 Double_t sumD=0;
 Double_t prob=0;
 Double_t gammaP1=0;
 Double_t gammaP2=0;
 Double_t ri=0;
 
 for(Int_t i=0; i<=Non; i++)
 {
  ri=i;
 
  // The incomplete gamma functions P(a,x)
  gammaP1=math.Gamma(Non+Noff+1-i,bmax*(Ton+Toff),0);
  gammaP2=math.Gamma(i+1,smax*Ton,0);
 
  // The ln of the numerator of Eq.(21) of the publication mentioned above normalized by Non!/(Non+Noff)!
  lnU=-s*Ton+ri*log(s)+ri*log(Ton+Toff)-lnfacN[i]-lnfacN[Non-i]+lnfacN[Non+Noff-i]-lnfacN[Non+Noff]+lnfacN[Non];
   
  if ((lnU > -fabs(prec)) && (lnU < fabs(prec))) sumU+=exp(lnU)*gammaP1;
   
  //The ln of the denominator of Eq.(21) of the publication mentioned above normalized by Non!/(Non+Noff)!
  lnD=ri*log(Ton+Toff)-(ri+1.)*log(Ton)-lnfacN[i]-lnfacN[Non-i]+lnfacN[Non+Noff-i]+lnfacN[i]-lnfacN[Non+Noff]+lnfacN[Non];
 
  if ((lnD > -fabs(prec)) && (lnD < fabs(prec))) sumD+=exp(lnD)*gammaP1*gammaP2;
 }
 
 if (sumD) prob=sumU/sumD;
 
 return prob;
}

TF1 NcAstrolab::GetBackgroundRatePDF(Double_t Noff,Double_t Toff,Double_t bmax,Double_t prec)
{
 
 if (bmax<0) bmax=100.*Noff/Toff;
 
 Int_t npar=4;
 TF1 pdf("BkgRatePDF",this,&NcAstrolab::GetBackgroundRateProb,0,bmax,npar,"NcAstrolab","GetBackgroundRateProb");
 
 pdf.SetParName(0,"Noff");
 pdf.SetParName(1,"Toff");
 pdf.SetParName(2,"bmax");
 pdf.SetParName(3,"prec");
 
 pdf.SetParameter("Noff",Noff); 
 pdf.SetParameter("Toff",Toff); 
 pdf.SetParameter("bmax",bmax); 
 pdf.SetParameter("prec",prec); 
 
 pdf.SetTitle("Bayesian posterior background rate PDF;Background rate B in Hz;p(B|Noff,Toff,I)");
 pdf.SetRange(0,bmax);
 
 return pdf;
}

TF1 NcAstrolab::GetSignalRatePDF(Double_t Non,Double_t Ton,Double_t Noff,Double_t Toff,Double_t Ra,Double_t Re,Double_t smax,Double_t bmax,Double_t prec)
{
 
 if (smax<0) smax=100.*Non/Ton;
 
 // Correct the off source observation for different coverage and detection efficiency
 // with respect to the actual on source measurement
 Noff=Noff*Ra*Re;
 
 if (bmax<0) bmax=100.*Noff/Toff;
 
 Int_t npar=7;
 TF1 pdf("SignalRatePDF",this,&NcAstrolab::GetSignalRateProb,0,smax,npar,"NcAstrolab","GetSignalRateProb");
 
 pdf.SetParName(0,"Non");
 pdf.SetParName(1,"Ton");
 pdf.SetParName(2,"Noff");
 pdf.SetParName(3,"Toff");
 pdf.SetParName(4,"smax");
 pdf.SetParName(5,"bmax");
 pdf.SetParName(6,"prec");
 
 pdf.SetParameter("Non",Non); 
 pdf.SetParameter("Ton",Ton); 
 pdf.SetParameter("Noff",Noff); 
 pdf.SetParameter("Toff",Toff); 
 pdf.SetParameter("smax",smax); 
 pdf.SetParameter("bmax",bmax); 
 pdf.SetParameter("prec",prec); 
 
 pdf.SetTitle("Bayesian posterior signal rate PDF;Signal rate S in Hz;p(S|Non,Ton,Noff,Toff,I)");
 pdf.SetRange(0,smax);
 
 return pdf;
}

Double_t NcAstrolab::GetUpperLimit(TF1 pdf,Double_t p)
{
 
 if (p<=0 || p>100) return 0;
 
 Double_t ua[2];
 Double_t xa[2];
 Int_t nu=0;
 Double_t ul=0;
 
 xa[0]=p/100.;
 nu=pdf.GetQuantiles(1,ua,xa);
 
 if (nu) ul=ua[0];
 
 return ul;
}

Double_t NcAstrolab::GetUpperLimit(TH1* his,Double_t p)
{
 
 if (p<=0 || p>100 || !his) return 0;
 
 Double_t ua[2];
 Double_t xa[2];
 Int_t nu=0;
 Double_t ul=0;
 
 // Ensure correct results als for histograms filled via SetBinContent().
 his->ComputeIntegral();
 
 xa[0]=p/100.;
 nu=his->GetQuantiles(1,ua,xa);
 
 if (nu) ul=ua[0];
 
 return ul;
}

Double_t NcAstrolab::GetCredibleInterval(TF1 pdf,Double_t p,Double_t& xlow,Double_t& xup,Int_t n)
{
 
 xlow=0;
 xup=0;
 
 if (p<=0 || p>100 || n<2) return 0;
 
 // Set the precision
 Double_t prec=1./double(n);
 
 // Obtain the n quantiles of the PDF
 Double_t* q=new Double_t[n];
 Double_t* sumq=new Double_t[n];
 Double_t sum=0;
 for (Int_t i=0; i<n; i++)
 {
  sumq[i]=sum;
  sum+=prec;
 }
 Int_t ncalc=pdf.GetQuantiles(n,q,sumq);
 
 // More than 1 quantile is needed
 if (ncalc<2)
 {
  delete [] q;
  delete [] sumq;
  return 0;
 }
 
 // Determine the index in the quantiles array q[] corresponding to
 // the X coordinate of the mode of the PDF
 Double_t xmode=pdf.GetMaximumX();
 Int_t imode=0;
 Double_t diff,diffmin;
 diffmin=fabs(q[ncalc-1]-q[0]);
 for (Int_t i=0; i<ncalc; i++)
 {
  diff=fabs(xmode-q[i]);
  if (diff<diffmin)
  {
   diffmin=diff;
   imode=i;
  }
 }
 
 // Get the total integral over the quantiles range of the PDF
 Double_t xmin=q[0];
 Double_t xmax=q[ncalc-1];
 Double_t totint=pdf.Integral(xmin,xmax);
 
 // The PDF should have a total integral >0
 if (totint<=0)
 {
  delete [] q;
  delete [] sumq;
  return 0;
 }
 
 // Determine the requested credible interval around the mode
 Int_t ilow=imode;
 Int_t iup=imode;
 xlow=q[ilow];
 xup=q[iup];
 Double_t ylow=pdf.Eval(q[ilow]);
 Double_t yup=pdf.Eval(q[iup]);
 Double_t frac=p/100.;
 if (frac>1) frac=1;
 Double_t credint=-1;
 while (credint<frac*totint)
 {
  if (yup>ylow && iup<(ncalc-1)) // Shift the upper bound up
  {
   iup++;
   xup=q[iup];
   yup=pdf.Eval(xup);
  }
  else if (ylow>yup && ilow>0) // Shift the lower bound down
  {
   ilow--;
   xlow=q[ilow];
   ylow=pdf.Eval(xlow);
  }
  else if (iup<(ncalc-1)) // Shift the upper bound up in case yup=ylow
  {
   iup++;
   xup=q[iup];
   yup=pdf.Eval(xup);
  }
  else if (ilow>0) // Shift the lower bound down in case yup=ylow
  {
   ilow--;
   xlow=q[ilow];
   ylow=pdf.Eval(xlow);
  }
  else // No shift in any bound -> stop
  {
   break;
  }
  credint=pdf.Integral(xlow,xup);
 }
 
 // Normalisation for non-normalised PDF
 Double_t intfrac=credint/totint;
 
 delete [] q;
 delete [] sumq;
 
 return intfrac;
}

Double_t NcAstrolab::GetCredibleInterval(TF1 pdf,Double_t p,Float_t& xlow,Float_t& xup,Int_t n)
{
 
 Double_t xxl=0;
 Double_t xxu=0;
 Double_t val=0;
 
 val=GetCredibleInterval(pdf,p,xxl,xxu,n);
 
 xlow=xxl;
 xup=xxu;
 return val;
}

Double_t NcAstrolab::GetCredibleInterval(TH1* his,Double_t p,Double_t& xlow,Double_t& xup)
{
 
 xlow=0;
 xup=0;
 
 if (p<=0 || p>100 || !his) return 0;
 
 Int_t nbins=his->GetNbinsX();
 
 // More than 2 bins are always needed
 if (nbins<2) return 0;
 
 // Ensure correct results also for histograms filled via SetBinContent()
 his->ComputeIntegral();
 
 // Obtain the quantiles at the end of each bin of the histogram and at the start of the 1st bin
 Int_t n=nbins+1;
 Double_t* q=new Double_t[n];
 Int_t ncalc=his->GetQuantiles(n,q);
 
 // More than 1 quantile is needed
 if (ncalc<2)
 {
  delete [] q;
  return 0;
 }
 
 // Determine the index in the quantiles array q[] corresponding to
 // the X coordinate of the mode of the histogram
 Int_t imode=his->GetMaximumBin();
 
 // Get the total integral of the histogram over the quantiles range
 Double_t totint=his->Integral(1,ncalc,"width");
 
 // The histogram should have a total integral >0
 if (totint<=0)
 {
  delete [] q;
  return 0;
 }
 
 // Determine the requested credible interval around the mode
 Int_t ilow=imode;
 Int_t iup=imode;
 xlow=q[ilow];
 xup=q[iup];
 Double_t ylow=his->GetBinContent(ilow);
 Double_t yup=his->GetBinContent(iup);
 Double_t frac=p/100.;
 if (frac>1) frac=1;
 Double_t credint=-1;
 while (credint<frac*totint)
 {
  if (yup>ylow && iup<(ncalc-1)) // Shift the upper bound up
  {
   iup++;
   xup=q[iup];
   yup=his->GetBinContent(iup);
  }
  else if (ylow>yup && ilow>0) // Shift the lower bound down
  {
   ilow--;
   xlow=q[ilow];
   ylow=his->GetBinContent(ilow);
  }
  else if (iup<(ncalc-1)) // Shift the upper bound up in case yup=ylow
  {
   iup++;
   xup=q[iup];
   yup=his->GetBinContent(iup);
  }
  else if (ilow>0) // Shift the lower bound down in case yup=ylow
  {
   ilow--;
   xlow=q[ilow];
   ylow=his->GetBinContent(ilow);
  }
  else // No shift in any bound -> stop
  {
   break;
  }
  credint=his->Integral(ilow,iup,"width");
 }
 
 // Normalisation for non-normalised PDF
 Double_t intfrac=credint/totint;
 
 delete [] q;
 
 return intfrac;
}

Double_t NcAstrolab::GetCredibleInterval(TH1* his,Double_t p,Float_t& xlow,Float_t& xup)
{
 
 Double_t xxl=0;
 Double_t xxu=0;
 Double_t val=0;
 
 val=GetCredibleInterval(his,p,xxl,xxu);
 
 xlow=xxl;
 xup=xxu;
 return val;
}

Double_t NcAstrolab::KolmogorovTest(TString mode,TH1* h1,TH1* h2,TF1* pdf,Double_t nr,TH1F* ksh,Int_t ncut,Double_t* nrx,Int_t mark)
{
 
 Double_t value=-1;
 
 if (!mode.Contains("M") && !mode.Contains("K") && !mode.Contains("P")) return -1;
 if (mode.Contains("M") && (mode.Contains("K") || mode.Contains("P"))) return -1;
 if (mode.Contains("K") && (mode.Contains("M") || mode.Contains("P"))) return -1;
 if (mode.Contains("P") && (mode.Contains("M") || mode.Contains("K"))) return -1;
 
 if (!h1) return -1;
 if (!h2 && !pdf) return -1;
 if (h2 && pdf) return -1;
 
 ULong64_t nrep=ULong64_t(nr);
 ULong64_t jrep;
 if (!nrep)
 {
  if (ncut)
  {
   nrep=ULong64_t(1.e19);
  }
  else
  {
   return -1;
  }
 }
 
 TAxis* xaxis=h1->GetXaxis();
 Double_t xmin1=xaxis->GetXmin();
 Double_t xmax1=xaxis->GetXmax();
 Double_t range1=xmax1-xmin1;
 Int_t nbins1=h1->GetNbinsX();
 Double_t nen1=h1->GetSumOfWeights();
 Double_t underflow1=h1->GetBinContent(0);
 Double_t overflow1=h1->GetBinContent(nbins1+1);
 if (mode.Contains("U")) nen1=nen1+underflow1;
 if (mode.Contains("O")) nen1=nen1+overflow1;
 
 if (nbins1<=0 || nen1<=0 || range1<=0)
 {
  cout << " *" << ClassName() << "::KolmogorovTest* Histogram h1 is empty or has inconsistent data." << endl;
  cout << " h1 : nentries=" << nen1 << " nbins=" << nbins1 << " xmin=" << xmin1 << " xmax=" << xmax1 << endl;
  return -1;
 }
 
 if (h2)
 {
  xaxis=h2->GetXaxis();
  Double_t xmin2=xaxis->GetXmin();
  Double_t xmax2=xaxis->GetXmax();
  Double_t range2=xmax2-xmin2;
  Int_t nbins2=h2->GetNbinsX();
  Double_t nen2=h2->GetSumOfWeights();
 
  if (nen2<=0 || range2<=0)
  {
   cout << " *" << ClassName() << "::KolmogorovTest* Histogram h2 is empty or has inconsistent data." << endl;
   cout << " h2 : nentries=" << nen2 << " nbins=" << nbins2 << " xmin=" << xmin2 << " xmax=" << xmax2 << endl;
   return -1;
  }
 
  Double_t prec=1e-6;
  if (nbins2!=nbins1 || fabs(xmin2-xmin1)>prec || fabs(xmax2-xmax1)>prec)
  {
   cout << " *" << ClassName() << "::KolmogorovTest* Histograms h1 and h2 do not have the same binning." << endl;
   cout << " h1 : nbins=" << nbins1 << " xmin=" << xmin1 << " xmax=" << xmax1 << endl;
   cout << " h2 : nbins=" << nbins2 << " xmin=" << xmin2 << " xmax=" << xmax2 << endl;
   return -1;
  }
 }
 
 // Create the "h2" histogram from the "pdf" function to perform the KS test
 if (pdf)
 {
  pdf->SetRange(xmin1,xmax1);
  pdf->SetNpx(nbins1);
  h2=(TH1*)pdf->GetHistogram()->Clone();
  h2->SetName("hpdf");
  // Set all bin errors (incl. underflow and overflow bins) to zero
  for (Int_t i=0; i<=nbins1+1; i++)
  {
   h2->SetBinError(i,0);
  }
 }
 
 // Convert "mode" into the corresponding character string for TH1::KolmogorovTest
 TString s="";
 if (mode.Contains("U")) s+="U";
 if (mode.Contains("O")) s+="O";
 if (mode.Contains("N") && !pdf) s+="N";
 
 // Obtain the maximum KS distance (d0) for the input histogram "h1"
 TString s2=s;
 s2+="M";
 Double_t d0=h2->KolmogorovTest(h1,s2.Data());
 
 // Complete "mode" conversion
 if (mode.Contains("M")) s+="M";
 if (mode.Contains("I")) s+="D";
 
 // Perform the requested KS test
 if (mode.Contains("I"))
 {
  if (pdf)
  {
   cout << " *" << ClassName() << "::KolmogorovTest* Single sample KS-test results for execution mode "<< mode.Data() << endl;
   if (mode.Contains("N")) cout << " === For a single sample KS-test the mode=N is suppressed ===" << endl;
  }
  else
  {
   cout << " *" << ClassName() << "::KolmogorovTest* Two sample KS-test results for execution mode "<< mode.Data() << endl;
  }
 }
 value=h1->KolmogorovTest(h2,s.Data());
 
 // Perform the pseudo experiments, if requested
 if (ksh) ksh->SetBins(101,0,1.01);
 Double_t xval=0;
 Double_t dist=0;
 Double_t sumrep=0;
 Int_t sumd=0;
 TH1* htemp=0;
 if (mode.Contains("P"))
 {
  htemp=(TH1*)h1->Clone();
  for (jrep=0; jrep<nrep; jrep++) // Loop of pseudo experiments
  {
   htemp->Reset();
   for (Int_t ien=0; ien<nen1; ien++) // Take the random entries from the reference distribution
   {
    xval=h2->GetRandom();
    htemp->Fill(xval);
   }
   dist=htemp->KolmogorovTest(h2,s2.Data());
   if (ksh) ksh->Fill(dist);
   sumrep+=1;
   if (dist>=d0) sumd++;
 
   // Stop the pseudo experiments if the required precision is reached
   if (ncut && sumd>=ncut) break;
 
  } // end loop over pseudo experiments
  value=double(sumd)/sumrep;
  if (nrx) *nrx=sumrep;
  if (mode.Contains("I"))
  {
   cout << " P-value        = " << value << " after " << sumrep << " pseudo experiments." << endl;
  }
 }
 
 if (mode.Contains("I")) cout << " Returned value = " << value << endl;
 
 // Complete the attributes for the "ksh" histogram
 if (ksh)
 {
  TString xlabel="Dmax";
  TString ylabel="Counts after ";
  ylabel+=sumrep;
  ylabel+=" pseudo experiments";
 
  ksh->SetTitle("KS-test Dmax distribution from pseudo experiments");
  ksh->SetXTitle(xlabel.Data());
  ksh->SetYTitle(ylabel.Data());
 
  // Mark the actually observed D0 value by a vertical line in the "ksh" histogram
  // Also the corresponding P-value is mentioned in the legend
  if (mark)
  {
   Float_t x=d0;
   Float_t ymin=0;
   Float_t ymax=ksh->GetMaximum();
 
   TLine* vline=new TLine(x,ymin,x,ymax);
   vline->SetLineStyle(2); // Dashed line
   vline->SetLineWidth(2);
   vline->SetLineColor(4); // Blue color
 
   TString title="P-value : %-10.3g";
   TString sh=title.Format(title.Data(),value);
 
   TLegend* leg=new TLegend(0.6,0.8,0.8,0.9);
   leg->SetFillColor(0);
   leg->SetHeader(sh.Data());
   leg->AddEntry(vline,"Observed Dmax","L");
 
   TList* hlist=ksh->GetListOfFunctions();
   hlist->Add(vline);
   hlist->Add(leg);
  }
 }
 
 // Delete temporary histograms, if any
 if (pdf && h2)
 {
  delete h2;
  h2=0;
 }
 
 if (htemp) delete htemp;
 
 return value;
}

TH1F NcAstrolab::GetCumulHistogram(TH1* h,TString name,TString mode) const
{
 
 TH1F hcd;
 TString title="Cumulative Distribution of histogram ";
 hcd.SetNameTitle(name.Data(),title.Data());
 
 if (!h) return hcd;
 
 TAxis* xaxis=h->GetXaxis();
 TAxis* yaxis=h->GetYaxis();
 Double_t xmin=xaxis->GetXmin();
 Double_t xmax=xaxis->GetXmax();
 Double_t range=xmax-xmin;
 Int_t nbins=h->GetNbinsX();
 Double_t nen=h->GetSumOfWeights();
 TString nameh=h->GetName();
 TString xtitle=xaxis->GetTitle();
 TString ytitle=yaxis->GetTitle();
 title+=nameh;
 hcd.SetNameTitle(name.Data(),title.Data());
 hcd.SetXTitle(xtitle.Data());
 hcd.SetYTitle(ytitle.Data());
 
 if (nbins<=0 || nen<=0 || range<=0) return hcd;
 
 if(!(mode.Contains("F") || mode.Contains("B")) || (mode.Contains("F") && mode.Contains("B"))) return hcd;
 
 hcd.SetBins(nbins,xmin,xmax);
 title="";
 if (mode.Contains("N")) title="Normalized ";
 if (mode.Contains("F")) title+="Forward ";
 if (mode.Contains("B")) title+="Backward ";
 title+="Cumulative Distribution of histogram ";
 title+=nameh;
 hcd.SetNameTitle(name.Data(),title.Data());
 hcd.SetXTitle(xtitle.Data());
 hcd.SetYTitle(ytitle.Data());
 
 Double_t norm=1;
 if (mode.Contains("N")) norm=nen;
 Double_t y=0;
 Double_t sum=0;
 
 if (mode.Contains("F")) // Forward cumulation
 {
  for (Int_t ibin=1; ibin<=nbins; ibin++)
  {
   y=h->GetBinContent(ibin);
   sum+=y/norm;
   hcd.SetBinContent(ibin,sum);
  }
 }
 else // Backward cumulation
 {
  for (Int_t ibin=nbins; ibin>=1; ibin--)
  {
   y=h->GetBinContent(ibin);
   sum+=y/norm;
   hcd.SetBinContent(ibin,sum);
  }
 }
 return hcd;
}

TH1F NcAstrolab::GetCumulHistogram(TF1* f,TString name,Int_t nbins,Double_t xmin,Double_t xmax,TString mode) const
{
 
 TH1F hcd;
 TString title="Cumulative Distribution Histogram of function ";
 hcd.SetNameTitle(name.Data(),title.Data());
 
 if (!f) return hcd;
 
 // The original range of the function "f"
 Double_t xminold=f->GetXmin();
 Double_t xmaxold=f->GetXmax();
 
 f->SetRange(xmin,xmax);
 f->SetNpx(nbins);
 TH1* hf=(TH1*)f->GetHistogram();
 
 hcd=GetCumulHistogram(hf,name,mode);
 
 if (hcd.GetEntries()>0) // Histogram has been filled
 {
  title="";
  if (mode.Contains("N")) title="Normalized ";
  if (mode.Contains("F")) title+="Forward ";
  if (mode.Contains("B")) title+="Backward ";
  title+="Cumulative Distribution Histogram of function ";
 }
 
 TString namef=f->GetName();
 title+=namef;
 
 hcd.SetTitle(title.Data());
 
 // Restore the original range for the function "f"
 f->SetRange(xminold,xmaxold);
 
 return hcd;
}

void NcAstrolab::InitDataNames(Int_t dir,TString frame,TString mode)
{
 
 if (!dir || (frame!="equ" && frame!="gal" && frame!="ecl" && frame!="hor" && frame!="icr" && frame!="loc") ||
     (mode!="M" && mode!="T" && mode!="B" && mode!="J"))
 {
  cout << endl;
  cout << " *" << ClassName() << "::InitDataNames* Invalid input encountered." << endl;
  cout << " dir=" << dir << " frame=" << frame << " mode=" << mode << endl;
  return;
 }
 
 fDataDir=dir;
 fDataFrame=frame;
 fDataMode=mode;
 
 // Reset the correspondence table
 fDataNames.Reset();
 
 TString sdir="arrival";
 if (dir<0) sdir="moving";
 
 if (frame=="equ")
 {
  if (mode=="M") frame="mean";
  if (mode=="T") frame="true";
  if (mode=="B") frame="B1950";
  if (mode=="J") frame="J2000";
  frame+=" equatorial";
 }
 if (frame=="gal") frame="galactic";
 if (frame=="ecl") frame="ecliptic";
 if (frame=="hor") frame="horizontal";
 if (frame=="icr") frame="ICRS";
 if (frame=="loc") frame="local";
 
 cout << endl;
 cout << " *" << ClassName() << "::InitDataNames* Prepared for input of " << sdir << " directions in " << frame << " coordinates." << endl; 
 cout << endl;
}

void NcAstrolab::SetDataNames(TString obsname,TString varname,TString units,TString func)
{
 
 Bool_t error=kFALSE;
 
 if (obsname!="Name" && obsname!="Run" && obsname!="Event" && obsname!="Eventb" && obsname!="VetoLevel"
     && obsname!="DetId" && obsname!="Date" && obsname!="Tobs" && obsname!="Tstart" && obsname!="Tend"
     && obsname!="d" && obsname!="a" && obsname!="b" && obsname!="z"
     && obsname!="E" && obsname!="L" && obsname!="S" && obsname!="F" && obsname!="I" && obsname!="J"
     && obsname!="T90" && obsname!="T100"
     && obsname!="dsigma" && obsname!="csigma" && obsname!="zsigma"
     && obsname!="Esigma" && obsname!="Lsigma" && obsname!="Ssigma" && obsname!="Fsigma" && obsname!="Isigma"
     && obsname!="T90sigma" && obsname!="T100sigma") error=kTRUE;
 if (obsname=="Date" && (units!="ddmmyyyy" && units!="yyyymmdd" && units!="mmddyyyy" && units!="yyyyddmm")) error=kTRUE;
 if ((obsname=="Tobs" || obsname=="Tstart" || obsname=="Tend")
     && (units!="JD" && units!="MJD" && units!="TJD" && units!="hms" && units!="hrs")) error=kTRUE;
 if ((obsname=="a" || obsname=="b" || obsname=="csigma")
     && (units!="rad" && units!="deg" && units!="dms" && units!="hms" && units!="hrs")) error=kTRUE;
 if (func!="none" && func!="Log" && func!="Ln") error=kTRUE;
 
 if (error)
 {
  cout << " *" << ClassName() << "::SetDataNames* Invalid input encountered." << endl;
  cout << " obsname=" << obsname << " units=" << units << " func=" << func << endl;
  return;
 }
 
 Int_t n=fDataNames.GetMaxRow();
 TObjString* obs=new TObjString(obsname);
 TObjString* var=new TObjString(varname);
 TObjString* u=new TObjString(units);
 TObjString* f=new TObjString(func);
 TObjString* val=new TObjString(""); // Value will be filled in LoadInputData()
 
 fDataNames.EnterObject(n+1,1,obs);
 fDataNames.EnterObject(n+1,2,var);
 fDataNames.EnterObject(n+1,3,u);
 fDataNames.EnterObject(n+1,4,f);
 fDataNames.EnterObject(n+1,5,val);
}

void NcAstrolab::ListDataNames()
{
 
 TString sdir="undefined";
 if (fDataDir>0) sdir="arrival";
 if (fDataDir<0) sdir="moving";
 
 TString frame="undefined";
 if (fDataFrame=="equ")
 {
  if (fDataMode=="M") frame="mean";
  if (fDataMode=="T") frame="true";
  if (fDataMode=="B") frame="B1950";
  if (fDataMode=="J") frame="J2000";
  frame+=" equatorial";
 }
 if (fDataFrame=="gal") frame="galactic";
 if (fDataFrame=="ecl") frame="ecliptic";
 if (fDataFrame=="hor") frame="horizontal";
 if (fDataFrame=="icr") frame="ICRS";
 if (fDataFrame=="loc") frame="local";
 
 cout << endl;
 cout << " *" << ClassName() << "::ListDataNames* Settings for input of " << sdir << " directions in " << frame << " coordinates." << endl; 
 
 Int_t n=fDataNames.GetMaxRow();
 
 if (n<1)
 {
  cout << " *** No settings were specified ***" << endl;
 }
 else
 {
  cout << " *** The following " << n << " settings were specified ***" << endl;
 }
 
 TObjString* obs=0;
 TObjString* var=0;
 TObjString* u=0;
 TObjString* f=0;
 for (Int_t i=1; i<=n; i++)
 {
  obs=(TObjString*)fDataNames.GetObject(i,1);
  var=(TObjString*)fDataNames.GetObject(i,2);
  u=(TObjString*)fDataNames.GetObject(i,3);
  f=(TObjString*)fDataNames.GetObject(i,4);
  cout << " obsname=" << obs->GetString() << " varname=" << var->GetString() << " units=" << u->GetString() << " func=" << f->GetString() << endl;
 }
 cout << endl;
}

void NcAstrolab::SetBurstParameter(TString name,Double_t value)
{
 
 if (!fBurstParameters)
 {
  fBurstParameters=new NcDevice();
  fBurstParameters->SetNameTitle("BurstParameters","Parameter settings for transient burst investigations");
 }
 
 if (name!="*")
 {
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(value,name);
 }
 else
 {
  Double_t pi=acos(-1.);
  name="Nmaxsrc";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-1,name);
  name="Nmaxevt";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-1,name);
  name="RAmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="RAmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(360,name);
  name="Declmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-90,name);
  name="Declmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(90,name);
  name="T90min";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e-5,name);
  name="T90max";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e5,name);
  name="Zmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-1e-6,name);
  name="Zmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(20,name);
  name="Sigmamin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Sigmamax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(2,name);
  name="Grbnu";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Avgrbz";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-1,name);
  name="Avgrbt90";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-1,name);
  name="Inburst";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Dtnu";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Dtnus";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-0.5,name);
  name="ESigmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e3,name);
  name="ESigmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e10,name);
  name="Ezcor";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
  name="Emin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(200,name);
  name="Emax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e7,name);
  name="Alphasig";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(2,name);
  name="Alphabkg";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(3.5,name);
  name="Kinangle";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(3,name);
  name="Angresmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Angresmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(2,name);
  name="Angresfix";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
  name="Recoangle";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(3,name);
  name="Sumsigmas";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(2,name);
  name="Timres";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e-5,name);
  name="Sensarea";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1e6,name);
  name="Bkgrate";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-0.003/(2.*pi),name);
  name="Nbkg";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
  name="Tunits";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(2,name);
  name="Tmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(-3600,name);
  name="Tmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(3600,name);
  name="Dawin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(5,name);
  name="Datype";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(0,name);
  name="Tbint90";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
  name="Tbin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
  name="VarTbin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(10,name);
  name="Abin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(1,name);
 
  // Remove all histograms related to burst investigations
  fBurstHistos.Clear();
  fBurstHistos.SetOwner();
 }

 // Store some derived parameters //
 
 // The correction factor to get from Tunits to seconds
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 Double_t Tfact=1;
 if (fTunits==0) Tfact=86400;
 if (fTunits==1) Tfact=3600;
 if (fTunits==3) Tfact=1e-9;
 if (fTunits==4) Tfact=1e-12;
 name="Tfact";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(Tfact,name);
 
 // Combined burst position and event reconstruction angular uncertainty interval (sigma in degrees)
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Float_t fSigmamin=fabs(fBurstParameters->GetSignal("Sigmamin"));
 Float_t fAngresmin=fBurstParameters->GetSignal("Angresmin");
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 if (!fRecoangle) fAngresmin=fAngresfix;
 Float_t Minsigmatot=-1;
 if (fSumsigmas==-1) Minsigmatot=fAngresmin;
 if (fSumsigmas==0) Minsigmatot=fSigmamin;
 if (fSumsigmas==1) Minsigmatot=fSigmamin+fAngresmin;
 if (fSumsigmas==2) Minsigmatot= sqrt(fSigmamin*fSigmamin+fAngresmin*fAngresmin);
 name="Minsigmatot";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(Minsigmatot,name);
 Float_t fSigmamax=fBurstParameters->GetSignal("Sigmamax");
 Float_t fAngresmax=fBurstParameters->GetSignal("Angresmax");
 if (!fRecoangle) fAngresmax=fAngresfix;
 Float_t Maxsigmatot=-1;
 if (fSumsigmas==-1) Maxsigmatot=fAngresmax;
 if (fSumsigmas==0) Maxsigmatot=fSigmamax;
 if (fSumsigmas==1) Maxsigmatot=fSigmamax+fAngresmax;
 if (fSumsigmas==2) Maxsigmatot= sqrt(fSigmamax*fSigmamax+fAngresmax*fAngresmax);
 name="Maxsigmatot";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(Maxsigmatot,name);
 
 // The total search time window in seconds
 Float_t fTmin=fBurstParameters->GetSignal("Tmin");
 Float_t fTmax=fBurstParameters->GetSignal("Tmax");
 Float_t Dtwin=fTmax-fTmin;
 name="Dtwin";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(Dtwin,name);
 
 Float_t fTbin=fBurstParameters->GetSignal("Tbin");
 if (!fTbin) // Center the time window around the burst trigger for variable time bins
 {
  fTmin=-Dtwin/2.;
  fTmax=Dtwin/2.;
  name="Tmin";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(fTmin,name);
  name="Tmax";
  fBurstParameters->AddNamedSlot(name);
  fBurstParameters->SetSignal(fTmax,name);
 }
 
 // The solid angle corresponding to the selected declination band
 Float_t fRAmin=fBurstParameters->GetSignal("RAmin");
 Float_t fRAmax=fBurstParameters->GetSignal("RAmax");
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 Float_t phimin=fRAmin;
 Float_t phimax=fRAmax;
 Float_t thmin=90.-fDeclmax;
 Float_t thmax=90.-fDeclmin;
 Float_t OmegaDecl=GetSolidAngle(thmin,thmax,"deg",phimin,phimax,"deg");
 name="OmegaDecl";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(OmegaDecl,name);
 
 // Background event rate from the selected declination band
 Float_t fBkgrate=fBurstParameters->GetSignal("Bkgrate");
 Float_t RbkgDecl=fBkgrate;
 if (fBkgrate<0)
 {
  RbkgDecl=fabs(fBkgrate)*OmegaDecl;
 }
 name="RbkgDecl";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(RbkgDecl,name);
 
 // Mean number of background events per hour from the selected declination band
 Float_t NbkgHour=RbkgDecl*3600.;
 name="NbkgHour";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(NbkgHour,name);
 
 // Mean number of background events in the search time window from the selected declination band
 Float_t fDtwin=fBurstParameters->GetSignal("Dtwin");
 Float_t NbkgWin=RbkgDecl*fDtwin*Tfact;
 name="NbkgWin";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(NbkgWin,name);
}

NcDevice* NcAstrolab::GetBurstParameters()
{
 
 return fBurstParameters;
}

void NcAstrolab::ListBurstParameters() const
{
 
 // User provided settings
 Int_t fNmaxsrc=TMath::Nint(fBurstParameters->GetSignal("Nmaxsrc"));
 Int_t fNmaxevt=TMath::Nint(fBurstParameters->GetSignal("Nmaxevt"));
 Float_t fRAmin=fBurstParameters->GetSignal("RAmin");
 Float_t fRAmax=fBurstParameters->GetSignal("RAmax");
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 Float_t fT90min=fBurstParameters->GetSignal("T90min");
 Float_t fT90max=fBurstParameters->GetSignal("T90max");
 Float_t fZmin=fBurstParameters->GetSignal("Zmin");
 Float_t fZmax=fBurstParameters->GetSignal("Zmax");
 Float_t fSigmamin=fBurstParameters->GetSignal("Sigmamin");
 Float_t fSigmamax=fBurstParameters->GetSignal("Sigmamax");
 Float_t fGrbnu=fBurstParameters->GetSignal("Grbnu");
 Float_t fAvgrbz=fBurstParameters->GetSignal("Avgrbz");
 Float_t fAvgrbt90=fBurstParameters->GetSignal("Avgrbt90");
 Float_t fAvgrbsigma=fBurstParameters->GetSignal("Avgrbsigma");
 Int_t fInburst=TMath::Nint(fBurstParameters->GetSignal("Inburst"));
 Float_t fDtnu=fBurstParameters->GetSignal("Dtnu");
 Float_t fDtnus=fBurstParameters->GetSignal("Dtnus");
 Float_t fESigmin=fBurstParameters->GetSignal("ESigmin");
 Float_t fESigmax=fBurstParameters->GetSignal("ESigmax");
 Int_t fEzcor=TMath::Nint(fBurstParameters->GetSignal("Ezcor"));
 Float_t fEmin=fBurstParameters->GetSignal("Emin");
 Float_t fEmax=fBurstParameters->GetSignal("Emax");
 Float_t fAlphasig=fBurstParameters->GetSignal("Alphasig");
 Float_t fAlphabkg=fBurstParameters->GetSignal("Alphabkg");
 Int_t fKinangle=TMath::Nint(fBurstParameters->GetSignal("Kinangle"));
 Float_t fAngresmin=fBurstParameters->GetSignal("Angresmin");
 Float_t fAngresmax=fBurstParameters->GetSignal("Angresmax");
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 Float_t fTimres=fBurstParameters->GetSignal("Timres");
 Float_t fSensarea=fBurstParameters->GetSignal("Sensarea");
 Float_t fBkgrate=fBurstParameters->GetSignal("Bkgrate");
 Int_t fNbkg=TMath::Nint(fBurstParameters->GetSignal("Nbkg"));
 Float_t fTmin=fBurstParameters->GetSignal("Tmin");
 Float_t fTmax=fBurstParameters->GetSignal("Tmax");
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 Float_t fDawin=fBurstParameters->GetSignal("Dawin");
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Int_t fTbint90=TMath::Nint(fBurstParameters->GetSignal("Tbint90"));
 Float_t fTbin=fBurstParameters->GetSignal("Tbin");
 Float_t fVarTbin=fBurstParameters->GetSignal("VarTbin");
 Float_t fAbin=fBurstParameters->GetSignal("Abin");
 
 // Derived parameters
 Float_t fMaxsigmatot=fBurstParameters->GetSignal("Maxsigmatot");
 Float_t fMinsigmatot=fBurstParameters->GetSignal("Minsigmatot");
 Float_t fOmegaDecl=fBurstParameters->GetSignal("OmegaDecl");
 Float_t fRbkgDecl=fBurstParameters->GetSignal("RbkgDecl");
 Float_t fNbkgHour=fBurstParameters->GetSignal("NbkgHour");
 Float_t fNbkgWin=fBurstParameters->GetSignal("NbkgWin");
 
 // Internal statistics
 Int_t fNgrbs=TMath::Nint(fBurstParameters->GetSignal("Ngrbs"));
 Int_t fNevts=TMath::Nint(fBurstParameters->GetSignal("Nevts"));
 
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 cout << " ========================= User provided source c.q. burst settings ===============================" << endl;
 if (fNmaxsrc<0)
 {
  printf(" No limitation has been put on the number of sources to be accepted for analysis. \n");
 }
 else
 {
  printf(" Maximal number of sources to be accepted for analysis : %-i \n",fNmaxsrc);
 }
 if (fNmaxevt<0)
 {
  printf(" No limitation has been put on the number of observed events to be accepted for analysis. \n");
 }
 else
 {
  printf(" Maximal number of observed events to be accepted for analysis : %-i \n",fNmaxevt);
 }
 printf(" Right ascension interval (J2000 in degrees) for source c.q. event position acceptance : [%-g,%-g] \n",fRAmin,fRAmax);
 printf(" Declination interval (J2000 in degrees) for source c.q. event position acceptance : [%-g,%-g] \n",fDeclmin,fDeclmax);
 printf(" Redshift interval for source acceptance : [%-g,%-g] \n",fabs(fZmin),fZmax);
 if (fZmin<0) printf(" Random redshift values taken from z-distribution in case of unknown redshift \n");
 if (fAvgrbz>=0) printf(" User defined average source redshift : %-g \n",fAvgrbz);
 printf(" Event energy interval (in GeV) for event acceptance : [%-g,%-g] \n",fEmin,fEmax);
 printf(" Position uncertainty interval (sigma in degrees) for source acceptance : [%-g,%-g] \n",fabs(fSigmamin),fSigmamax);
 if (fSigmamin<0) printf(" Random sigma values taken from sigma-distribution when missing in loaded data \n");
 printf(" Event angular resolution interval (sigma in degrees) for event acceptance : [%-g,%-g] \n",fAngresmin,fAngresmax);
 if (fDatype>0) printf(" Sigma (combination) selection (-1=event sigma only  0=source sigma only  1=linear summation  2=quadratic summation) : %-i \n",fSumsigmas);
 if (fDawin>=0)
 {
  if (fDatype<0) printf(" Unrestricted angular search area. \n");
  if (!fDatype) printf(" Fixed angular search circle around the source position : %-g degrees \n",fDawin);
  if (fDatype==1) printf(" Fixed angular search circle (in combined max. source/event sigma) around the source position : %-g \n",fDawin);
  if (fDatype==2) printf(" Variable angular search circle (in combined actual source/event sigma) around the source position : %-g \n",fDawin);
 }
 else
 {
  if (fDatype<0) printf(" Unrestricted angular search area. \n");
  if (!fDatype) printf(" Fixed angular local zenith band above/below the source position : %-g degrees \n",fabs(fDawin));
  if (fDatype==1) printf(" Fixed angular local zenith band (in combined max. source/event sigma) above/below the source position : %-g \n",fabs(fDawin));
  if (fDatype==2) printf(" Variable angular local zenith band (in combined actual source/event sigma) above/below the source position : %-g \n",fabs(fDawin));
 }
 printf(" Number of requested background patches per source : %-i \n",fNbkg);
 if (fT90max>0)
 {
  printf(" Duration interval (t90 in sec) for burst acceptance : [%-g,%-g] \n",fabs(fT90min),fT90max);
  if (fT90min<0) printf(" Random values taken from T90-distribution in case T90 and T100 were missing \n");
  if (fAvgrbt90>0) printf(" User defined average burst T90 duration : %-g sec. \n",fAvgrbt90);
  if (fTmax>fTmin) printf(" Total search time window (in %-s) with the burst trigger at t=0 : [%-g,%-g] \n",tu.Data(),fTmin,fTmax);
 }
 if (fTmax<=fTmin) printf(" Search will be performed with no restrictions on the time window \n");
 if (fTbin<0) printf(" Automatic time histogram binning with as mean number of bkg counts/bin : %-g \n",fabs(fTbin));
 if (!fTbin) printf(" Variable time histogram binning with as size (in %-s) for the first time : %-g \n",tu.Data(),fVarTbin);
 if (fTbin>0)
 {
  if (fTbint90)
  {
   printf(" Time histogram bin size in average T90 units : %-g",fTbin);
   if (fAvgrbt90>0 || fNgrbs>0) printf(" (=%-g sec)",fTbin*fabs(fAvgrbt90));
   printf("\n");
  }
  else
  {
   printf( " Time histogram bin size : %-g %-s \n",fTbin,tu.Data());
  }
 }
 if (fAbin<0)
 {
  printf(" Automatic angular histogram binning with as mean number of bkg counts per bin : %-g \n",fabs(fAbin));
 }
 else
 {
  printf(" Angular histogram bin size : %-g degrees \n",fAbin);
 }
 
 // Parameters for burst signal and background generation
 if (fGrbnu)
 {
  if (fGrbnu<0)
  {
   printf(" Number of generated neutrinos per burst : %-g without statistical fluctuations \n",fabs(fGrbnu));
  }
  else
  {
   printf(" Maximum number of generated neutrinos per burst : %-g \n",fGrbnu);
   printf(" The actual number of neutrinos may be less due to statistical fluctuations \n");
  }
  printf(" Energy interval (in GeV) for signal event generation at the source : [%-g,%-g] \n",fESigmin,fESigmax);
  if (fEzcor)
  {
   printf(" The signal neutrino energy at Earth will be corrected for redshift \n"); 
  }
  else
  {
   printf(" No redshift correction will be applied on the generated signal neutrino energy \n"); 
  }
  if (!fInburst)
  {
   printf(" Neutrino production is assumed to be NOT coupled to the observed burst duration \n");
   printf(" Mean decoupled time difference between burst gammas/GW and neutrinos : %-g sec. \n",fDtnu);
  }
  else
  {
   printf(" Neutrino production is assumed to be coupled to the observed burst duration \n");
   printf(" Mean coupled time difference (in units of T90 w.r.t. trigger) between burst gammas/GW and neutrinos : %-g",fDtnu);
  }
  if (fDtnus>=0)
  {
   printf(" Sigma of mean time difference between burst gammas/GW and neutrinos : %-g sec. \n",fDtnus);
  }
  else
  {
   printf(" Sigma of mean time difference (in units of T90) between burst gammas/GW and neutrinos : %-g \n",fabs(fDtnus));
  }
  printf(" Default spectral index for a dN/dE=E^-alpha source induced signal energy spectrum within [%-g,%-g] GeV : %-g \n",fEmin,fEmax,fAlphasig);
  printf(" --- The user may have changed the spectrum by invokation of the memberfunction MakeBurstEnergydist(). \n");
  printf(" Default spectral index for a dN/dE=E^-alpha background energy spectrum within [%-g,%-g] GeV : %-g \n",fEmin,fEmax,fAlphabkg);
  printf(" --- The user may have changed the spectrum by invokation of the memberfunction MakeBurstEnergydist(). \n");
  printf(" Fixed event reco angular resolution (sigma in degrees), also used when no distribution (value) is available : %-g \n",fAngresfix);
  printf(" Event reconstruction angular uncertainty selection (0=use fixed value  1=mean 2=median 3=draw from distribution) : %-i \n",fRecoangle);
  printf(" Neutrino-lepton kinematic opening angle selection for CC interactions (0=none 1=mean 2=median 3=draw from pdf) : %-i \n",fKinangle);
 }
 
 printf("\n");
 printf(" Time resolution of the neutrino detector : %-g sec. \n",fTimres);
 printf(" Area covered c.q. overlooked by the neutrino detector : %-g m^2 \n",fSensarea);
 if (fBkgrate) printf(" User defined mean rate of background events for the specified declination interval (<0 : rate per steradian) : %-g Hz \n",fBkgrate);
 
 printf("\n");
 printf(" ============================== Derived parameters ==================================== \n");
 printf(" Combined source position and event reco angular uncertainty interval (sigma in degrees) : [%-g,%-g] \n",fMinsigmatot,fMaxsigmatot);
 printf(" Solid angle coverage corresponding to the selected declination band : %-g steradian \n",fOmegaDecl);
 if (fBkgrate)
 {
  printf(" Background event rate (from user setting) for the selected declination band : %-g Hz \n",fRbkgDecl);
  printf(" Mean number of background events (from user setting) per hour from the selected declination band : %-g \n",fNbkgHour);
  printf(" Mean number of background events (from user setting) in the time window from the selected declination band : %-g \n",fNbkgWin);
 }
 if (fNgrbs>0)
 {
  printf(" Number of bursts accepted for analysis : %-i \n",fNgrbs);
  printf(" Median source redshift from the data sample : %-g \n",fabs(fAvgrbz));
  if (fAvgrbt90) printf(" Median burst T90 duration from the data sample : %-g sec. \n",fabs(fAvgrbt90));
  printf(" Median souce position uncertainty (sigma in degrees) from the data sample : %-g \n",fAvgrbsigma);
 }
 if (fNevts>0) printf(" Number of observed events accepted for analysis : %-i \n",fNevts);
 printf(" ====================================================================================== \n");
 printf("\n");
}

void NcAstrolab::LoadInputData(Bool_t src,TString file,TString tree,Int_t date1,Int_t date2,Int_t nmax,TString type)
{
 
 // Set the default type identifier
 if (type=="-" && src) type="GRB";
 if (type=="-" && !src) type="EVT";
 
 Int_t nvars=fDataNames.GetMaxRow();
 
 if (nvars<1)
 {
  cout << " *" << ClassName() << "::LoadInputData* No variables were specified for " << type << " data."<< endl;
  return;
 }
 
 // Set the data mode : observed events or source data
 Int_t iobs=1;
 if (src) iobs=0;
 
 // Retreive the needed parameters
 Int_t fNmaxsrc=TMath::Nint(fBurstParameters->GetSignal("Nmaxsrc"));
 Int_t fNmaxevt=TMath::Nint(fBurstParameters->GetSignal("Nmaxevt"));
 Float_t fRAmin=fBurstParameters->GetSignal("RAmin");
 Float_t fRAmax=fBurstParameters->GetSignal("RAmax");
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 Float_t fT90min=fBurstParameters->GetSignal("T90min");
 Float_t fT90max=fBurstParameters->GetSignal("T90max");
 Float_t fZmin=fBurstParameters->GetSignal("Zmin");
 Float_t fZmax=fBurstParameters->GetSignal("Zmax");
 Float_t fSigmamin=fBurstParameters->GetSignal("Sigmamin");
 Float_t fSigmamax=fBurstParameters->GetSignal("Sigmamax");
 Float_t fEmin=fBurstParameters->GetSignal("Emin");
 Float_t fEmax=fBurstParameters->GetSignal("Emax");
 Float_t fAngresmin=fBurstParameters->GetSignal("Angresmin");
 Float_t fAngresmax=fBurstParameters->GetSignal("Angresmax");
 
 // Internal statistics
 Int_t fNgrbs=GetNsignals(0);
 Int_t fNevts=GetNsignals(1);
 
 // Get access to a redshift distribution to draw randomly source redshifts if needed
 TH1* zdist=0;
 if (src && fZmin<0) zdist=GetBurstZdist("LoadInputData()",type);
 
 // Get access to a T90 distribution to draw randomly source c.q. burst T90 values if needed
 TH1* t90dist=0;
 if (src && fT90min<0) t90dist=GetBurstT90dist("LoadInputData()",type);
 
 // Get access to a 1-sigma position uncertainty distribution to draw randomly source position uncertaintes
 TH1* sigmaposdist=0;
 if (src && fSigmamin<0) sigmaposdist=GetBurstSigmaPosdist("LoadInputData()",type);
 
 // The TTree containing the source (c.q. burst) or observed event data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 // The pre-defined (physical) observables
 TString obsname;
 TString varname;
 TString units;
 TString func;
 
 // The (physical) observable value in string format
 TObjString* pval=0;
 TString val;
 
 // The retrieved numerical (physical) observable value from the ROOT Tree
 Double_t value=0;
 
 // The conversion factor depending on the units specification 
 Double_t fact=0;
 
 // Some of the pre-defined observable values that are used for selections
 // or that need special treatment
 TString Name,Date,Tobs,Tstart,Tend;
 Double_t d,a,b;
 Float_t z,csigma,T90,T100,E;
 
 UInt_t yyyy,mm,dd; // The date format
 Int_t h,m;  // The integer hour and minute time format
 Double_t s; // The (fractional) seconds time format
 Int_t dmode=0;
 Int_t idate=0;
 Int_t jdate=0;
 TString grbname;
 NcTimestamp tobs;
 NcTimestamp tstart;
 NcTimestamp tend;
 NcSignal* sx=0;
 Int_t nnew=0;
 TLeaf* lx=0;
 TLeafC* lxc=0;
 Int_t jlast=0;
 
 // Create or increase the corresponding storage array to hold the new data
 Int_t nent=data.GetEntries();
 Int_t size=0;
 if (src) // Input represents reference objects
 {
  if (!fRefs)
  {
   fRefs=new TObjArray(nent);
   fRefs->SetOwner();
  }
  else
  {
   size=fRefs->GetSize();
   fRefs->Expand(size+nent);
  }
 }
 else // Input represents measured signals
 {
  if (!fSigs)
  {
   fSigs=new TObjArray(nent);
   fSigs->SetOwner();
  }
  else
  {
   size=fSigs->GetSize();
   fSigs->Expand(size+nent);
  }
 }
 
 // Loop over the data entries in the input Tree
 for (Int_t ient=0; ient<nent; ient++)
 {
  if (nmax>=0 && nnew>=nmax) break;
  if (src && fNmaxsrc>=0 && (fNgrbs+nnew)>=fNmaxsrc) break;
  if (!src && fNmaxevt>=0 && (fNevts+nnew)>=fNmaxevt) break;
 
  data.GetEntry(ient);
 
  // Initialisation of the values that are used for selections
  // or that need special treatment
  Name="none";
  Date="none";
  Tobs="none";
  Tstart="none";
  Tend="none";
  d=-999;
  a=-999;
  b=-999;
  z=-999;
  csigma=-999;
  T90=-999;
  T100=-999;
  E=-999;
 
  // Loop over the selected input variables and retrieve the corresponding input value
  for (Int_t ivar=1; ivar<=nvars; ivar++)
  {
   obsname=((TObjString*)fDataNames.GetObject(ivar,1))->GetString();
   varname=((TObjString*)fDataNames.GetObject(ivar,2))->GetString();
   units=((TObjString*)fDataNames.GetObject(ivar,3))->GetString();
   func=((TObjString*)fDataNames.GetObject(ivar,4))->GetString();
 
   pval=(TObjString*)fDataNames.GetObject(ivar,5);
 
   if (!pval) continue;
 
   lx=data.GetLeaf(varname);
   
   // Record -999 for missing data
   if (!lx)
   {
    pval->SetString("-999");
    continue;
   }
 
   if (obsname=="Name") // Character string data from the input Tree
   {
    value=0;
    lxc=(TLeafC*)lx;
    Name=lxc->GetValueString();
   }
   else // Numerical data from the input Tree
   {
    value=lx->GetValue();
   }
 
   if (func=="Log") value=pow(10,value);
   if (func=="Ln") value=exp(value);
 
   // Convert all angular values to degrees
   if (obsname=="a" || obsname=="b" || obsname=="csigma") value=ConvertAngle(value,units,"deg");
 
   // Convert numerical values to the standard units
   if (units.IsFloat())
   {
    fact=units.Atof();
    value*=fact;
   }
 
   // Store the obtained value in string format
   val="";
   val+=value;
   pval->SetString(val);
 
   // Special values needed for later selections
   if (obsname=="Date")
   {
    Date="";
    Date+=int(value);
    if (units=="ddmmyyyy") dmode=0;
    if (units=="yyyymmdd") dmode=1;
    if (units=="mmddyyyy") dmode=2;
    if (units=="yyyyddmm") dmode=3;
   }
   if (obsname=="Tobs")
   {
    Tobs="set"; // Indicate that Tobs is encountered
    if (units=="JD") tobs.SetJD(value);
    if (units=="MJD") tobs.SetMJD(value);
    if (units=="TJD") tobs.SetTJD(value);
    if (units=="hms")
    {
     Tobs="";
     Tobs+=value;
    }
    if (units=="hrs") // Convert "hrs" to "hms" time format
    {
     Tobs="";
     Convert(value,h,m,s);
     value=s+double(100*m+10000*h);
     Tobs+=value;
    }
   }
   if (obsname=="Tstart")
   {
    Tstart="set"; // Indicate that Tstart is encountered
    if (units=="JD") tstart.SetJD(value);
    if (units=="MJD") tstart.SetMJD(value);
    if (units=="TJD") tstart.SetTJD(value);
    if (units=="hms")
    {
     Tstart="";
     Tstart+=value;
    }
    if (units=="hrs") // Convert "hrs" to "hms" time format
    {
     Tstart="";
     Convert(value,h,m,s);
     value=s+double(100*m+10000*h);
     Tstart+=value;
    }
   }
   if (obsname=="Tend")
   {
    Tend="set"; // Indicate that Tend is encountered
    if (units=="JD") tend.SetJD(value);
    if (units=="MJD") tend.SetMJD(value);
    if (units=="TJD") tend.SetTJD(value);
    if (units=="hms")
    {
     Tend="";
     Tend+=value;
    }
    if (units=="hrs") // Convert "hrs" to "hms" time format
    {
     Tend="";
     Convert(value,h,m,s);
     value=s+double(100*m+10000*h);
     Tend+=value;
    }
   }
 
   if (obsname=="d") d=value;  
   if (obsname=="a") a=value;  
   if (obsname=="b") b=value;  
   if (obsname=="z") z=value;  
   if (obsname=="csigma") csigma=value;  
   if (obsname=="T90") T90=value;  
   if (obsname=="T100") T100=value;
   if (obsname=="E") E=value;  
  } // End of the loop over the selected input variables
 
  // For angular coordinates the distance may be irrelevant
  if (d<=0) d=1;
 
  // Check for the presence of valid location data
  if (a<-900 || b<-900) continue;
 
  // Check on (RA,DEC) acceptance in case of J2000 equatorial coordinates
  if (fDataFrame=="equ" && fDataMode=="J" && (a<fRAmin || a>fRAmax || b<fDeclmin || b>fDeclmax)) continue;
 
  // Construct the various timestamps from the (date,time) specification if needed
  if (Tobs!="none" && Tobs!="set" && Date!="none") tobs.SetUT(Date,Tobs,dmode);  
  if (Tstart!="none" && Tstart!="set" && Date!="none") tstart.SetUT(Date,Tstart,dmode);  
  if (Tend!="none" && Tend!="set" && Date!="none") tend.SetUT(Date,Tend,dmode);
 
  // Check for the presence of a valid observation c.q. trigger timestamp
  if (Tobs=="none" || (Tobs!="set" && Date=="none")) continue;
 
  // Obtain the date in yyyymmdd format
  tobs.GetDate(kTRUE,0,&yyyy,&mm,&dd);
  idate=dd+100*mm+10000*yyyy;
 
  if (Name!="none") // Set the name of the object or observation
  {
   grbname=Name;
  }
  else // Compose the name of the source c.q. burst with the common yymmdd suffix
  {
   jdate=idate%1000000;
   grbname=type;
   if (jdate<100000) grbname+="0"; // Add leading zero for the year if needed
   grbname+=jdate;
  }
 
  if (date1 && idate<date1) continue;
  if (date2 && idate>date2) continue;
 
  if (src) // Source c.q. burst specific selections
  {
   if (T90<=0) T90=T100;
   if (fT90min<0 && T90<0 && t90dist) T90=t90dist->GetRandom();
 
   if (T90<fabs(fT90min) || T90>fT90max) continue;
 
   if (fZmin<0 && z<0 && zdist) z=zdist->GetRandom();
 
   if (z<fabs(fZmin) || z>fZmax) continue;
 
   if (fSigmamin<0 && csigma<0 && sigmaposdist) csigma=sigmaposdist->GetRandom();
 
   if (csigma<fabs(fSigmamin) || csigma>fSigmamax) continue;
  }
  else // Observed event specific selections
  {
   if (E<fEmin || E>fEmax) continue;
   if (csigma<fAngresmin || csigma>fAngresmax) continue;
  }
 
  // Store the location c.q. arrival direction data
  sx=SetSignal(d,a,"deg",b,"deg",fDataFrame,&tobs,-1,fDataMode,grbname,iobs);
 
  // Obtain the RA and DEC coordinates for acceptance selection if input was not in J2000
  if (fDataFrame!="equ" || fDataMode!="J")
  {
   jlast=GetSignalIndex(sx,iobs);
   GetSignal(d,a,"deg",b,"deg","equ",&tobs,jlast,"J",iobs);
 
   // Remove the signal again when it falls outside the acceptance
   if (a<fRAmin || a>fRAmax || b<fDeclmin || b>fDeclmax)
   {
    RemoveSignal(jlast,iobs,0);
    sx=0;
    continue;
   }
  }
 
  if (!sx) continue;
 
  nnew++;
 
  // Storing the requested data in NcSignal slots
  for (Int_t ivar=1; ivar<=nvars; ivar++)
  {
   obsname=((TObjString*)fDataNames.GetObject(ivar,1))->GetString();
   val=((TObjString*)fDataNames.GetObject(ivar,5))->GetString();
 
   // The observable Name is not stored in the NcSignal slots
   if (obsname=="Name") continue;
 
   value=val.Atof();
 
   // The values of the observables a and b depend on the reference frame
   // They should be retrieved via the GetSignal() facility
   if (obsname=="a" || obsname=="b") continue;
 
   // The Date and timestamps in specific format
   if (obsname=="Date") value=idate;
   if (obsname=="Tobs") value=tobs.GetMJD();
   if (obsname=="Tstart") value=tstart.GetMJD();
   if (obsname=="TEnd") value=tend.GetMJD();
 
   // Values that may have got random values
   if (obsname=="z") value=z;
   if (obsname=="csigma") value=csigma;
   if (obsname=="T90") value=T90;
 
   sx->AddNamedSlot(obsname);
   sx->SetSignal(value,obsname);
  }
 } // End of loop over the entries of the input Tree
 
 // Compress the storage array size to the number of actually stored elements
 RemoveSignal(-1,iobs,1);
 
 Int_t nstored=GetNsignals(iobs);
 
 cout << endl;
 if (src)
 {
  // Update internal statistics
  fBurstParameters->AddNamedSlot("Ngrbs");
  fBurstParameters->SetSignal(nstored,"Ngrbs");
  cout << " *" << ClassName() << "::LoadInputData* " << nnew << " new source(s) of type " << type
       << " stored from Tree:" << tree << " of file(s):" << file << endl;
  cout << " Total number of stored sources c.q. bursts : " << nstored << endl;
 }
 else
 {
  // Update internal statistics
  fBurstParameters->AddNamedSlot("Nevts");
  fBurstParameters->SetSignal(nstored,"Nevts");
  cout << " *" << ClassName() << "::LoadInputData* " << nnew
       << " new observed event(s) were stored from Tree:" << tree << " of file(s):" << file << endl;
  cout << " Total number of stored events : " << nstored << endl;
 }
}

void NcAstrolab::GenBurstGCNdata(Int_t n,TString name,Bool_t scale)
{
 
 // Retreive the needed parameters
 Int_t fNmaxsrc=TMath::Nint(fBurstParameters->GetSignal("Nmaxsrc"));
 Float_t fRAmin=fBurstParameters->GetSignal("RAmin");
 Float_t fRAmax=fBurstParameters->GetSignal("RAmax");
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 Float_t fT90min=fBurstParameters->GetSignal("T90min");
 Float_t fT90max=fBurstParameters->GetSignal("T90max");
 Float_t fZmin=fBurstParameters->GetSignal("Zmin");
 Float_t fZmax=fBurstParameters->GetSignal("Zmax");
 Float_t fSigmamin=fBurstParameters->GetSignal("Sigmamin");
 Float_t fSigmamax=fBurstParameters->GetSignal("Sigmamax");
 Float_t fOmegaDecl=fBurstParameters->GetSignal("OmegaDecl");
 
 if (scale)
 {
  Double_t pi=acos(-1.);
  n=TMath::Nint(double(n)*fOmegaDecl/(4.*pi));
 }
 
 // Internal statistics
 Int_t fNgrbs=GetNsignals(0);
 
 // Get access to a redshift distribution to draw randomly redshifts
 TH1* zdist=GetBurstZdist("GenBurstGCNdata()",name);
 
 // Get access to a T90 distribution to draw randomly T90 values
 TH1* t90dist=GetBurstT90dist("GenBurstGCNdata()",name);
 
 // Get access to a 1-sigma position uncertainty distribution to draw randomly position uncertaintes
 TH1* sigmaposdist=GetBurstSigmaPosdist("GenBurstGCNdata()",name);
 
 if (!zdist || !t90dist || !sigmaposdist)
 {
  cout << endl;
  cout << " *" << ClassName() << "::GenBurstGCNdata* A distribution for random values is missing." << endl; 
  cout << endl;
  return;
 }
 
 Float_t thlow=90.-fDeclmax; // Lower theta angle in overall Earth spherical coordinates (North Pole is theta=0)
 Float_t thup=90.-fDeclmin;  // Upper theta angle in overall Earth spherical coordinates (North Pole is theta=0)
 Float_t phimin=fRAmin;      // Minimal phi angle in overall Earth spherical coordinates
 Float_t phimax=fRAmax;      // Maximal phi angle in overall Earth spherical coordinates
 if (thlow<0) thlow=0;
 if (thup>180) thup=180;
 
 NcSignal* sx=0;
 NcPosition rgrb;
 Float_t t90grb=0;
 Float_t zgrb=0;
 Float_t sigmagrb=0;
 TString grbname;
 Double_t thetagrb,phigrb,ragrb,decgrb;
 Int_t ngen=0;
 
 for (Int_t igrb=1; igrb<=n; igrb++)
 {
  if (fNmaxsrc>=0 && (fNgrbs+ngen)>=fNmaxsrc) break;
 
  zgrb=-1;
  if (fabs(fZmin)==fZmax) zgrb=fZmax; 
  while (zgrb<fabs(fZmin) || zgrb>fZmax)
  {
   zgrb=zdist->GetRandom();
  }
 
  t90grb=-1;
  if (fabs(fT90min)==fT90max) t90grb=fT90max; 
  while (t90grb<fabs(fT90min) || t90grb>fT90max)
  {
   t90grb=t90dist->GetRandom();
   t90grb=pow(float(10),t90grb);
  }
   
  sigmagrb=-1;
  if (fabs(fSigmamin)==fSigmamax) sigmagrb=fSigmamax; 
  while (sigmagrb<fabs(fSigmamin) || sigmagrb>fSigmamax)
  {
   sigmagrb=sigmaposdist->GetRandom();
  }
 
  rgrb.SetPosition(1,0,0,"sph","deg");
  RandomPosition(rgrb,thlow,thup,phimin,phimax);
  thetagrb=rgrb.GetX(2,"sph","deg");
  phigrb=rgrb.GetX(3,"sph","deg");
 
  grbname="Random-";
  grbname+=name;
  grbname+=igrb;
  grbname+="#";
  ragrb=phigrb;
  decgrb=90.-thetagrb;
  sx=SetSignal(1,ragrb,"deg",decgrb,"deg","equ",0,-1,"J",grbname);
 
  if (!sx) continue;
 
  ngen++;
 
  sx->AddNamedSlot("T90");
  sx->SetSignal(t90grb,"T90");
  sx->AddNamedSlot("csigma");
  sx->SetSignal(sigmagrb,"csigma");
  sx->AddNamedSlot("z");
  sx->SetSignal(zgrb,"z");
 
 }
 
 // Update internal statistics
 fNgrbs=GetNsignals(0);
 fBurstParameters->AddNamedSlot("Ngrbs");
 fBurstParameters->SetSignal(fNgrbs,"Ngrbs");
 
 cout << endl;
 cout << " *" << ClassName() << "::GenBurstGCNdata* " << ngen << " new generated bursts with name " << name << " were stored." << endl;
 cout << " Total number of stored bursts : " << fNgrbs << endl;
}

void NcAstrolab::MakeBurstZdist(TString file,TString tree,TString name,Int_t nb,Float_t zmin,Float_t zmax)
{
 
 // The Tree containing the archival data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 Int_t nen=data.GetEntries();
 TLeaf* lx=data.FindLeaf(name.Data());
 
 if (!nen || !lx)
 {
  cout << " *" << ClassName() << "::MakeBurstZdist* Missing information for tree variable:" << name << endl;
  cout << " of Tree:" << tree << " with " << nen <<  " entries in file:" << file << endl;
  return;
 }
 
 // Create new distributions in case a redshift distribution is not yet present
 TH1* zdist=(TH1*)fBurstHistos.FindObject("hz");
 if (!zdist)
 {
  // Creation of the archival burst redshift histogram
  TH1F* hz=new TH1F("hz","Archival data of observed burst redshifts",nb,zmin,zmax);
  fBurstHistos.Add(hz);
  hz->GetXaxis()->SetTitle("Burst redshift");
  hz->GetYaxis()->SetTitle("Counts");
 
  // Creation of the corresponding physical distance histo
  Float_t dmin=GetPhysicalDistance(zmin);
  Float_t dmax=GetPhysicalDistance(zmax);
  TH1F* hd=new TH1F("hd","Burst distances derived from the archival redshift data",nb,dmin,dmax);
  fBurstHistos.Add(hd);
  hd->GetXaxis()->SetTitle("Burst physical distance in Mpc");
  hd->GetYaxis()->SetTitle("Counts");
 }
 
 // Get pointers to the relevant histograms 
 TH1* hz=(TH1*)fBurstHistos.FindObject("hz");
 TH1* hd=(TH1*)fBurstHistos.FindObject("hd");
 
 Int_t nz=0;
 Double_t z=0;
 Double_t d=0;
 for (Int_t ien=0; ien<nen; ien++)
 {
  data.GetEntry(ien);
 
  lx=data.GetLeaf(name.Data());
  if (!lx) continue;
 
  z=lx->GetValue();
  if (z<zmin || z>zmax) continue;
 
  hz->Fill(z);
  nz++;
 
  d=GetPhysicalDistance(z);
  hd->Fill(d);
 }
 
 cout << " *" << ClassName() << "::MakeBurstZdist* " << nz << " archival z-values have been obtained from tree variable:" << name
      << " of Tree:" << tree << " in file(s):" << file << endl;
}

TH1* NcAstrolab::GetBurstZdist(TString name,TString type)
{
 
 TH1* zdist=(TH1*)fBurstHistos.FindObject("hz");
 if (!zdist)
 {
  if (type.Contains("GRB"))
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstZdist* Called from " << name << endl;
   cout << " *** Archival observed redshift distribution not found. ***" << endl;
   cout << " A Landau fit from Swift GRB redshift data will be used to provide missing c.q. random z values." << endl;
 
   zdist=(TH1*)fBurstHistos.FindObject("hZpdf");
   if (!zdist)
   { 
    TF1 fz("fz","59.54*TMath::Landau(x,1.092,0.5203)");
    fz.SetRange(0,10);
    fz.SetNpx(10000);
    TH1* hfz=fz.GetHistogram();
    zdist=(TH1*)hfz->Clone();
    zdist->SetNameTitle("hZpdf","Landau fit for Swift GRB z data");
    zdist->GetXaxis()->SetTitle("GRB redshift");
    zdist->GetYaxis()->SetTitle("Counts");
    fBurstHistos.Add(zdist);
   }
  }
  else // Source class for which no fit is available
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstZdist* Called from " << name << endl;
   cout << " *** No redshift fit is available for source class " << type << " ***" << endl;
  }
 }
 
 return zdist;
}

void NcAstrolab::MakeBurstT90dist(TString file,TString tree,TString name,Int_t nb,Float_t xmin,Float_t xmax)
{
 
 // The Tree containing the burst data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 Int_t nen=data.GetEntries();
 TLeaf* lx=data.FindLeaf(name.Data());
 
 if (!nen || !lx)
 {
  cout << " *" << ClassName() << "::MakeBurstT90dist* Missing information for tree variable:" << name << endl;
  cout << " of Tree:" << tree << " with " << nen <<  " entries in file:" << file << endl;
  return;
 }
 
 // Create a new distribution in case a T90 distribution is not yet present
 TH1* t90dist=(TH1*)fBurstHistos.FindObject("ht90");
 if (!t90dist)
 {
  // Creation of observed burst t90 duration histo
  TH1F* ht90=new TH1F("ht90","Archival data of observed burst durations",nb,xmin,xmax);
  fBurstHistos.Add(ht90);
  ht90->GetXaxis()->SetTitle("Burst duration ^{10}log(T90) in sec.");
  ht90->GetYaxis()->SetTitle("Counts");
 }
 
 // Get pointer to the relevant histogram 
 TH1* ht90=(TH1*)fBurstHistos.FindObject("ht90");
 
 Int_t nt90=0;
 Double_t t90=0;
 for (Int_t ien=0; ien<nen; ien++)
 {
  data.GetEntry(ien);
 
  lx=data.GetLeaf(name.Data());
  if (!lx) continue;
 
  t90=lx->GetValue();
  if (t90>0)
  {
   ht90->Fill(log10(t90));
   nt90++;
  }
 }
 
 cout << " *" << ClassName() << "::MakeBurstT90dist* " << nt90 << " archival T90 values have been obtained from variable:" << name
      << " of Tree:" << tree << " in file(s):" << file << endl;
}

TH1* NcAstrolab::GetBurstT90dist(TString name,TString type)
{
 
 TH1* t90dist=(TH1*)fBurstHistos.FindObject("ht90");
 if (!t90dist)
 {
  if (type.Contains("GRB"))
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstT90dist* Called from " << name << endl;
   cout << " *** Observational T90 distribution not found. ***" << endl;
   cout << " A double Gaussian fit from Fermi GRB T90 data will be used to provide missing c.q. random T90 values." << endl;
 
   t90dist=(TH1*)fBurstHistos.FindObject("hT90pdf");
   if (!t90dist)
   {
    TF1 ft("ft","44.39*TMath::Gaus(x,-0.131,0.481)+193.8*TMath::Gaus(x,1.447,0.4752)");
    ft.SetRange(-5,5);
    ft.SetNpx(10000);
    TH1* hft=ft.GetHistogram();
    t90dist=(TH1*)hft->Clone();
    t90dist->SetNameTitle("hT90pdf","Double Gauss fit for Fermi t90 data");
    t90dist->GetXaxis()->SetTitle("GRB duration ^{10}log(T90) in sec.");
    t90dist->GetYaxis()->SetTitle("Counts");
    fBurstHistos.Add(t90dist);
   }
  }
  else // Source class for which no fit is available
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstT90dist* Called from " << name << endl;
   cout << " *** No T90 fit is available for source class " << type << " ***" << endl;
  }
 }
 
 return t90dist;
}

void NcAstrolab::MakeBurstSigmaPosdist(TString file,TString tree,TString name,TString u,Int_t nb,Float_t xmin,Float_t xmax)
{
 
 // The Tree containing the burst data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 Int_t nen=data.GetEntries();
 TLeaf* lx=data.FindLeaf(name.Data());
 
 if (!nen || !lx)
 {
  cout << " *" << ClassName() << "::MakeBurstSigmaPosdist* Missing information for tree variable:" << name << endl;
  cout << " of Tree:" << tree << " with " << nen <<  " entries in file:" << file << endl;
  return;
 }
 
 // Create a new distribution in case a burst position uncertainty distribution is not yet present
 TH1* sigmaposdist=(TH1*)fBurstHistos.FindObject("hsigmapos");
 if (!sigmaposdist)
 {
  // Creation of observed 1-sigma burst position uncertainty histo
  TH1F* hsigmapos=new TH1F("hsigmapos","Archival data of observed 1-sigma burst position uncertainties",nb,xmin,xmax);
  fBurstHistos.Add(hsigmapos);
  hsigmapos->GetXaxis()->SetTitle("Burst position uncertainty (sigma in degrees)");
  hsigmapos->GetYaxis()->SetTitle("Counts");
 }
 
 // Get pointer to the relevant histogram 
 TH1* hsigmapos=(TH1*)fBurstHistos.FindObject("hsigmapos");
 
 Int_t nsigmapos=0;
 Double_t sigmapos=0;
 for (Int_t ien=0; ien<nen; ien++)
 {
  data.GetEntry(ien);
 
  lx=data.GetLeaf(name.Data());
  if (!lx) continue;
 
  sigmapos=lx->GetValue();
 
  // Convert declination to degrees if needed
  sigmapos=ConvertAngle(sigmapos,u,"deg");
 
  if (sigmapos<xmin || sigmapos>xmax) continue;
 
  hsigmapos->Fill(sigmapos);
  nsigmapos++;
 }
 
 cout << " *" << ClassName() << "::MakeBurstSigmaPosdist* " << nsigmapos << " archival sigmapos values have been obtained from variable:" << name
      << " of Tree:" << tree << " in file(s):" << file << endl;
}

TH1* NcAstrolab::GetBurstSigmaPosdist(TString name,TString type)
{
 
 TH1* sigmaposdist=(TH1*)fBurstHistos.FindObject("hsigmapos");
 if (!sigmaposdist)
 {
  if (type.Contains("GRB"))
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstSigmaPosdist* Called from " << name << endl;
   cout << " *** Archival observed GRB position uncertainty distribution not found. ***" << endl;
   cout << " A Landau fit from observed GRB data will be used to provide missing c.q. random 1-sigma uncertainty values." << endl;
 
   sigmaposdist=(TH1*)fBurstHistos.FindObject("hSigmaSourcePDF");
   if (!sigmaposdist)
   { 
    TF1 fsigmapos("fsigmapos","245.2*TMath::Landau(x,-2.209,0.6721,1)");
    fsigmapos.SetRange(0,90);
    fsigmapos.SetNpx(10000);
    TH1* hfsigmapos=fsigmapos.GetHistogram();
    sigmaposdist=(TH1*)hfsigmapos->Clone();
    sigmaposdist->SetNameTitle("hSigmaSourcePDF","Landau fit for burst 1-sigma position uncertainty data");
    sigmaposdist->GetXaxis()->SetTitle("Burst position uncertainty (sigma in degrees)");
    sigmaposdist->GetYaxis()->SetTitle("Counts");
    fBurstHistos.Add(sigmaposdist);
   }
  }
  else // Source class for which no fit is available
  {
   cout << endl;
   cout << " *" << ClassName() << "::GetBurstSigmaPosdist* Called from " << name << endl;
   cout << " *** No position uncertainty fit is available for source class " << type << " ***" << endl;
  }
 }
 
 return sigmaposdist;
}

void NcAstrolab::MakeBurstEnergydist(Int_t mode,TF1& spec,Double_t Emin,Double_t Emax,Int_t nbins)
{
 
 if (Emin<=0) Emin=1e-10;
 
 if ((mode!=1 && mode!=2) || Emax<=Emin)
 {
  cout << " *" << ClassName() << "::MakeBurstEnergydist* Inconsistent data: mode=" << mode << " Emin=" << Emin << " Emax=" << Emax << endl;
  return;
 }
 
 // Convert the energy boundaries to the log10 scale of the X-axis
 Double_t xmin=log10(Emin);
 Double_t xmax=log10(Emax);
 
 TString sf="dN/dE=";
 sf+=spec.GetExpFormula("p");
 if (mode==1) sf+=" background";
 if (mode==2) sf+=" signal";
 sf+=" distribution";
 sf.ReplaceAll("x","E");
 TString sh="";
 if (mode==1) sh="Background energy distribution;^{10}Log(E) in GeV;";
 if (mode==2) sh="Source induced signal energy distribution;^{10}Log(E) in GeV;";
 sh+=sf;
 TH1F his=GetCountsHistogram(spec,nbins,xmin,xmax,1,sh);
 
 // Remove the corresponding old distribution (if any) from the storage
 TH1* dist=0;
 if (mode==1) dist=(TH1*)fBurstHistos.FindObject("hBkgEpdf");
 if (mode==2) dist=(TH1*)fBurstHistos.FindObject("hSigEpdf");
 if (dist)
 {
  fBurstHistos.Remove(dist);
  fBurstHistos.Compress();
  delete dist;
  dist=0;
 }
 
 // Store the newly created distribution
 // and set a flag to indicate a parametrized distribution
 if (mode==1)
 {
  TH1F* hBkgEpdf=(TH1F*)his.Clone();
  hBkgEpdf->SetName("hBkgEpdf");
  fBurstHistos.Add(hBkgEpdf);
  fBurstParameters->AddNamedSlot("PDFbkgE");
  fBurstParameters->SetSignal(1,"PDFbkgE");
 }
 if (mode==2)
 {
  TH1F* hSigEpdf=(TH1F*)his.Clone();
  hSigEpdf->SetName("hSigEpdf");
  fBurstHistos.Add(hSigEpdf);
  fBurstParameters->AddNamedSlot("PDFsigE");
  fBurstParameters->SetSignal(1,"PDFsigE");
 }
 
 cout << " *" << ClassName() << "::MakeBurstEnergydist* Created a " << sf
      << " on [Emin,Emax]=[" << Emin << "," << Emax << "] GeV" << endl;
}

void NcAstrolab::MakeBurstEnergydist(Int_t mode,Double_t alpha,Double_t Emin,Double_t Emax,Int_t nbins)
{
 
 TF1 spec("spec","pow(x,[0])");
 spec.SetParameter(0,-alpha);
 MakeBurstEnergydist(mode,spec,Emin,Emax,nbins);
}

void NcAstrolab::MakeBurstEnergydist(Int_t mode,TString file,TString tree,TString name1,TString name2,TString u,Double_t Emin,Double_t Emax,Int_t nb)
{
 
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 
 if (Emin<=0) Emin=1e-10;
 
 if ((abs(mode)!=1 && abs(mode)!=2) || Emax<=Emin)
 {
  cout << " *" << ClassName() << "::MakeBurstEnergydist* Inconsistent data: mode=" << mode << " Emin=" << Emin << " Emax=" << Emax << endl;
  return;
 }
 
 // Convert the energy boundaries to the log10 scale of the X-axis
 Double_t xmin=log10(Emin);
 Double_t xmax=log10(Emax);
 
 // The Tree containing the burst data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 Int_t nen=data.GetEntries();
 
 if (!nen || !data.FindLeaf(name1.Data()) || !data.FindLeaf(name2.Data()))
 {
  cout << " *" << ClassName() << "::MakeBurstEnergydist* Missing information for tree variable:" << name1
       << " and/or tree variable:" << name2 << endl;
  cout << " of Tree:" << tree << " with " << nen <<  " entries in file:" << file << endl;
  return;
 }
 
 // A corresponding parametrized distribution will always be removed
 Int_t flag=0;
 if (abs(mode)==1) flag=TMath::Nint(fBurstParameters->GetSignal("PDFbkgE"));
 if (abs(mode)==2) flag=TMath::Nint(fBurstParameters->GetSignal("PDFsigE"));
 
 if (flag) mode=abs(mode);
 
 // Remove the corresponding old distribution (if requested) from the storage
 TH1* Edist=0;
 if (abs(mode)==1) Edist=(TH1*)fBurstHistos.FindObject("hBkgEpdf");
 if (abs(mode)==2) Edist=(TH1*)fBurstHistos.FindObject("hSigEpdf");
 
 if (mode>0 && Edist)
 {
  fBurstHistos.Remove(Edist);
  fBurstHistos.Compress();
  delete Edist;
  Edist=0;
 }
 
 // Create a new distribution if needed
 if (!Edist)
 {
  mode=abs(mode);
  if (mode==1)
  {
   // Creation of the observed background energy histo
   TH1F* hBkgEpdf=new TH1F("hBkgEpdf","Archival data of observed background energies",nb,xmin,xmax);
   fBurstHistos.Add(hBkgEpdf);
   hBkgEpdf->GetXaxis()->SetTitle("^{10}log(Energy) in GeV");
   hBkgEpdf->GetYaxis()->SetTitle("Counts");
   fBurstParameters->AddNamedSlot("PDFbkgE");
   fBurstParameters->SetSignal(0,"PDFbkgE");
  }
  if (mode==2)
  {
   // Creation of the observed signal energy histo
   TH1F* hSigEpdf=new TH1F("hSigEpdf","Archival data of observed signal energies",nb,xmin,xmax);
   fBurstHistos.Add(hSigEpdf);
   hSigEpdf->GetXaxis()->SetTitle("^{10}log(Energy) in GeV");
   hSigEpdf->GetYaxis()->SetTitle("Counts");
   fBurstParameters->AddNamedSlot("PDFsigE");
   fBurstParameters->SetSignal(0,"PDFsigE");
   fBurstParameters->SetSignal(0,"Ezcor");
  }
 }
 
 // Get pointer to the relevant histogram 
 if (abs(mode)==1) Edist=(TH1*)fBurstHistos.FindObject("hBkgEpdf");
 if (abs(mode)==2) Edist=(TH1*)fBurstHistos.FindObject("hSigEpdf");
 
 Int_t nE=0;
 Double_t logE=0;
 Double_t dec=0;
 TLeaf* lx=0;
 for (Int_t ien=0; ien<nen; ien++)
 {
  data.GetEntry(ien);
 
  lx=data.GetLeaf(name1.Data());
  if (!lx) continue;
 
  logE=lx->GetValue();
 
  lx=data.GetLeaf(name2.Data());
  if (!lx) continue;
 
  dec=lx->GetValue();
 
  // Convert declination to degrees if needed
  dec=ConvertAngle(dec,u,"deg");
 
  if (dec>=fDeclmin && dec<=fDeclmax)
  {
   Edist->Fill(logE);
   nE++;
  }
 }
 
 TString smode="";
 if (abs(mode)==1) smode="archival background";
 if (abs(mode)==2) smode="archival signal";
 
 if (mode>0)
 {
  cout << " *" << ClassName() << "::MakeBurstEnergydist* A new " << smode
       << " energy distribution has been created." << endl; 
 }
 else
 {
  cout << " *" << ClassName() << "::MakeBurstEnergydist* Statistics of the existing " << smode
       << " energy distribution have been increased." << endl; 
 }
 
 cout << "  " << nE << " energy values have been obtained from variable:" << name1
      << " of Tree:" << tree << " in file(s):" << file << endl;
}

void NcAstrolab::MakeBurstRecoAngresdist(TString file,TString tree,TString name1,TString name2,TString ua,TString name3,TString ud,Double_t Emin,Double_t Emax,Int_t nbe,Int_t nba)
{
 
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 
 if (Emin<=0) Emin=1e-10;
 
 if (Emax<=Emin)
 {
  cout << " *" << ClassName() << "::MakeBurstRecoAngresdist* Inconsistent data: Emin=" << Emin << " Emax=" << Emax << endl;
  return;
 }
 
 // Convert the energy boundaries to the log10 scale of the X-axis
 Double_t xmin=log10(Emin);
 Double_t xmax=log10(Emax);
 
 // The Tree containing the burst data
 TChain data(tree.Data());
 data.Add(file.Data());
 
 Int_t nen=data.GetEntries();
 
 if (!nen || !data.FindLeaf(name1.Data()) || !data.FindLeaf(name2.Data()) || !data.FindLeaf(name3.Data()))
 {
  cout << " *" << ClassName() << "::MakeBurstRecoAngresdist* Missing information for tree variable:" << name1
       << " and/or tree variable:" << name2 << " and/or tree variable:" << name3 << endl;
  cout << " of Tree:" << tree << " with " << nen <<  " entries in file:" << file << endl;
  return;
 }
 
 // Create a new distribution in case a reconstruction angle resolution vs. energy distribution is not yet present
 TH2* Angresdist=(TH2*)fBurstHistos.FindObject("hAngresE");
 if (!Angresdist)
 {
  // Creation of the observed reconstruction angle resolution vs. energy histo
  TH2F* hAngresE=new TH2F("hAngresE","Archival data of observed reconstruction angle resolution vs. energy",
  nbe,xmin,xmax,nba,0,180.1);
  fBurstHistos.Add(hAngresE);
  hAngresE->GetXaxis()->SetTitle("^{10}log(Energy) in GeV");
  hAngresE->GetYaxis()->SetTitle("Angular resolution in degrees");
 }
 
 // Get pointer to the relevant histogram 
 TH2* hAngresE=(TH2*)fBurstHistos.FindObject("hAngresE");
 
 Int_t nE=0;
 Double_t logE=0;
 Double_t dec=0;
 Double_t dang=0;
 TLeaf* lx=0;
 for (Int_t ien=0; ien<nen; ien++)
 {
  data.GetEntry(ien);
 
  lx=data.GetLeaf(name1.Data());
  if (!lx) continue;
 
  logE=lx->GetValue();
 
  lx=data.GetLeaf(name2.Data());
  if (!lx) continue;
 
  dang=lx->GetValue();
 
  // Convert declination to degrees if needed
  dang=ConvertAngle(dang,ua,"deg");
 
  lx=data.GetLeaf(name3.Data());
  if (!lx) continue;
 
  dec=lx->GetValue();
 
  // Convert declination to degrees if needed
  dec=ConvertAngle(dec,ud,"deg");
 
  if (dec>=fDeclmin && dec<=fDeclmax)
  {
   hAngresE->Fill(logE,dang);
   nE++;
  }
 }
 
 cout << " *" << ClassName() << "::MakeBurstRecoAngresdist* " << nE << " archival entries have been obtained for variables:" << name2
      << " vs. " << name1 << " of Tree:" << tree << " in file(s):" << file << endl;
}

Double_t NcAstrolab::GetBurstSignalEnergy(Double_t Emin,Double_t Emax) const
{
 
 Double_t E=-1;
 
 // Get pointer to the relevant histogram 
 TH1* hSigEpdf=(TH1*)fBurstHistos.FindObject("hSigEpdf");
 
 if (!hSigEpdf) return E;
 
 Int_t nbins=hSigEpdf->GetNbinsX();
 Int_t nentries=hSigEpdf->GetEntries();
 
 if (nbins<=0 || nentries<=0) return E;
 
 TAxis* xaxis=hSigEpdf->GetXaxis();
 
 if (!xaxis) return E;
 
 Double_t xlow=xaxis->GetBinLowEdge(1);
 Double_t xup=xaxis->GetBinUpEdge(nbins);
 
 Double_t logEmin=0;
 if (Emin<=0)
 {
  logEmin=xlow;
 }
 else
 {
  logEmin=log10(Emin);
 }
 
 Double_t logEmax=0;
 if (Emax<=0)
 {
  logEmax=xup;
 }
 else
 {
  logEmax=log10(Emax);
 }
 
 if (logEmax<=logEmin || logEmin>=xup || logEmax<=xlow) return E;
 
 while (E<logEmin || E>logEmax)
 {
  E=hSigEpdf->GetRandom();
 }
 
 E=pow(float(10),E);
 
 return E;
}

Double_t NcAstrolab::GetBurstBackgroundEnergy(Double_t Emin,Double_t Emax) const
{
 
 Double_t E=-1;
 
 // Get pointer to the relevant histogram 
 TH1* hBkgEpdf=(TH1*)fBurstHistos.FindObject("hBkgEpdf");
 
 if (!hBkgEpdf) return E;
 
 Int_t nbins=hBkgEpdf->GetNbinsX();
 Int_t nentries=hBkgEpdf->GetEntries();
 
 if (nbins<=0 || nentries<=0) return E;
 
 TAxis* xaxis=hBkgEpdf->GetXaxis();
 
 if (!xaxis) return E;
 
 Double_t xlow=xaxis->GetBinLowEdge(1);
 Double_t xup=xaxis->GetBinUpEdge(nbins);
 
 Double_t logEmin=0;
 if (Emin<=0)
 {
  logEmin=xlow;
 }
 else
 {
  logEmin=log10(Emin);
 }
 
 Double_t logEmax=0;
 if (Emax<=0)
 {
  logEmax=xup;
 }
 else
 {
  logEmax=log10(Emax);
 }
 
 if (logEmax<=logEmin || logEmin>=xup || logEmax<=xlow) return E;
 
 while (E<logEmin || E>logEmax)
 {
  E=hBkgEpdf->GetRandom();
 }
 
 E=pow(float(10),E);
 
 return E;
}

Double_t NcAstrolab::GetBurstRecoAngres(Double_t Emin,Double_t Emax,Double_t Amin,Double_t Amax) const
{
 
 Double_t dang=-1;
 
 if (Amin<0) Amin=0;
 
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 
 // The user requested a fixed angular resolution value "Angresfix"
 if (!fRecoangle)
 {
  dang=fAngresfix;
  return dang;
 }
 
 // The user requested an angular resolution based on a distribution
 
 // Get pointer to the reco angle resolution vs. energy distribution histogram 
 TH2* hAngresE=(TH2*)fBurstHistos.FindObject("hAngresE");
 
 // No distribution available -> Return the user provided "Angresfix" value
 if (!hAngresE)
 {
  dang=fAngresfix;
  return dang;
 }
 
 // Obtain the projected reco angle resolution distribution within the [Emin,Emax] interval
 
 Int_t nbins=hAngresE->GetNbinsX();
 Int_t nentries=hAngresE->GetEntries();
 
 if (nbins<=0 || nentries<=0) return dang;
 
 TAxis* xaxis=hAngresE->GetXaxis();
 
 if (!xaxis) return dang;
 
 Double_t xlow=xaxis->GetBinLowEdge(1);
 Double_t xup=xaxis->GetBinUpEdge(nbins);
 
 Double_t logEmin=0;
 if (Emin<=0)
 {
  logEmin=xlow;
 }
 else
 {
  logEmin=log10(Emin);
 }
 
 Double_t logEmax=0;
 if (Emax<=0)
 {
  logEmax=xup;
 }
 else
 {
  logEmax=log10(Emax);
 }
 
 if (logEmax<logEmin || logEmin>=xup || logEmax<=xlow) return dang;
 
 Int_t ilow=xaxis->FindBin(logEmin);
 Int_t iup=xaxis->FindBin(logEmax);
 
 TH1D* hproj=hAngresE->ProjectionY("hproj",ilow,iup);
 
 if (!hproj) return dang;
 
 nbins=hproj->GetNbinsX();
 nentries=hproj->GetEntries();
 
 if (nbins<=0 || nentries<=0) return dang;
 
 if (fRecoangle==1) dang=hproj->GetMean();
 
 if (fRecoangle==2)
 {
  NcSample q;
  dang=q.GetMedian(hproj);
 }
 
 if (fRecoangle==3)
 {
  xaxis=hproj->GetXaxis();
 
  if (!xaxis) return dang;
 
  xlow=xaxis->GetBinLowEdge(1);
  xup=xaxis->GetBinUpEdge(nbins);
 
  if (Amax<=Amin || Amin>=xup || Amax<=xlow) return dang;
  
  dang=Amin-1.;
  while (dang<Amin || dang>Amax)
  {
   dang=hproj->GetRandom();
  }
 }
 
 if (hproj) delete hproj;
 
 return dang;
}

void NcAstrolab::GenBurstSignals()
{
 
 // Signal and background generation can only be performed for a user defined fixed time window size
 Float_t fTmin=fBurstParameters->GetSignal("Tmin");
 Float_t fTmax=fBurstParameters->GetSignal("Tmax");
 if (fTmax<=fTmin)
 {
  printf("\n *%-s::GenBurstSignals* Error : [Tmin,Tmax]=[%-g,%-g] whereas Tmin<Tmax is required. \n",ClassName(),fTmin,fTmax);
  return;
 }
 
 // If needed, initialise the randomiser with a "date/time driven" seed
 // using the timestamp of the moment of this invokation of the member function.
 // This will ensure different random sequences if the user repeats analyses
 // with identical measurements and reference signals without explicit initialisation
 // of the randomiser by the user at the start of the analysis.
 if (!fRan) fRan=new NcRandom(-1);

 // Initialise the final sample histograms //
 
 InitBurstHistograms(0);
 
 // Retrieve the needed parameters
 Float_t fRAmin=fBurstParameters->GetSignal("RAmin");
 Float_t fRAmax=fBurstParameters->GetSignal("RAmax");
 Float_t fDeclmin=fBurstParameters->GetSignal("Declmin");
 Float_t fDeclmax=fBurstParameters->GetSignal("Declmax");
 Float_t fTimres=fBurstParameters->GetSignal("Timres");
 Int_t fEzcor=TMath::Nint(fBurstParameters->GetSignal("Ezcor"));
 Int_t fPDFsigE=TMath::Nint(fBurstParameters->GetSignal("PDFsigE"));
 Float_t fEmin=fBurstParameters->GetSignal("Emin");
 Float_t fEmax=fBurstParameters->GetSignal("Emax");
 Int_t fKinangle=TMath::Nint(fBurstParameters->GetSignal("Kinangle"));
 Float_t fAngresmin=fBurstParameters->GetSignal("Angresmin");
 Float_t fAngresmax=fBurstParameters->GetSignal("Angresmax");
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 Float_t fTfact=fBurstParameters->GetSignal("Tfact");
 Float_t fDawin=fBurstParameters->GetSignal("Dawin");
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Float_t fGrbnu=fBurstParameters->GetSignal("Grbnu");
 Int_t fInburst=TMath::Nint(fBurstParameters->GetSignal("Inburst"));
 Float_t fDtnu=fBurstParameters->GetSignal("Dtnu");
 Float_t fDtnus=fBurstParameters->GetSignal("Dtnus");
 Int_t fNbkg=TMath::Nint(fBurstParameters->GetSignal("Nbkg"));
 
 // Deactivate redshift correction for source signal events from archival observed data
 if (!fPDFsigE)
 {
  fEzcor=0;
  fBurstParameters->SetSignal(0,"Ezcor");
 } 
 
 // Derived parameters
 Float_t fMaxsigmatot=fBurstParameters->GetSignal("Maxsigmatot");
 Float_t fNbkgWin=fBurstParameters->GetSignal("NbkgWin");

 // Some Burst statistics from the loaded data //
 
 Int_t fNgrbs=GetNsignals(0);
 
 TH1* hSigmaReco=(TH1*)fBurstHistos.FindObject("hSigmaReco");
 TH1* hSigE=(TH1*)fBurstHistos.FindObject("hSigE");
 TH1* hSigEzcor=(TH1*)fBurstHistos.FindObject("hSigEzcor");

 // Generation of the signal and background observations //
 // based on the provided user settings                  //
 
 NcSignal* sx=0;
 Float_t zgrb=0;
 Double_t dgrb=0;
 Float_t t90grb=0;
 Float_t sigmagrb=0;
 NcPosition rgrb;
 Int_t nmu;
 Double_t thetagrb,phigrb;
 Double_t dmu,thetamu,phimu;
 Float_t dt=0;
 NcPosition rgrb2; // Unknown actual GRB position from which the neutrinos/muons arrive
 NcPosition rmu;
 Float_t dang;
 Float_t dangmax=0;
 Float_t dangmaxon=0;
 Float_t dangmaxoff=0;
 Float_t thlow,thup;
 Float_t ranlow,ranup;
 Int_t nmugrb=0;
 NcTimestamp* tx=0;
 NcTimestamp tmu;
 Float_t solidangle=0;
 Float_t ramu,decmu; // Temporary RA and DEC of muon for background creation
 Double_t E=0;
 Double_t ang=0;
 Double_t sigmareco=0;
 Float_t sigmatot=0;
 TString name;
 Int_t fixedwinset=0; // Flag to indicate whether a fixed angular search window is set (1) or not (0) for this burst
 
 // Storage for total on-source and off-source observed and signal injected energies
 fBurstParameters->AddNamedSlot("EnergyOn");
 fBurstParameters->AddNamedSlot("EnergyOff");
 fBurstParameters->AddNamedSlot("EnergySig");
 
 // Loop over the (fictative) GRB space-time positions in the declination acceptance
 for (Int_t igrb=0; igrb<fNgrbs; igrb++)
 {
  sx=GetSignal(igrb+1);
 
  if (!sx) continue;
 
  tx=sx->GetTimestamp();
  zgrb=sx->GetSignal("z");
  t90grb=sx->GetSignal("T90");
  sigmagrb=sx->GetSignal("csigma");
  GetSignal(dgrb,thetagrb,"deg",phigrb,"deg","loc",tx,igrb+1);
  rgrb.SetPosition(1,thetagrb,phigrb,"sph","deg");
 
  dangmax=-1;
  if (!fDatype) dangmax=fabs(fDawin);
  if (fDatype==1)
  {
   dangmax=0;
   if (fMaxsigmatot>0) dangmax=fabs(fDawin*fMaxsigmatot);
  }
 
  if (fDatype==2)
  {
   if (!fSumsigmas) dangmax=fabs(fDawin*sigmagrb);
   if (!fRecoangle)
   {
    sigmatot=-1;
    if (fSumsigmas==-1) sigmatot=fAngresfix;
    if (fSumsigmas==1) sigmatot=sigmagrb+fAngresfix;
    if (fSumsigmas==2) sigmatot=sqrt(sigmagrb*sigmagrb+fAngresfix*fAngresfix);
    if (sigmatot>=0) dangmax=fabs(fDawin*sigmatot);
   }
  }
 
  fixedwinset=1;
  if (dangmax<0) fixedwinset=0;
 
  // Indicate incompatible input for sigma summation
  if (fDatype==1 && fMaxsigmatot<0) dangmax=-1;
 
  // New signal slots for storage of maximum angular differences and corresponding solid angles
  name="fixedwinset";
  sx->AddNamedSlot(name);
  sx->SetSignal(fixedwinset,name);
  name="dangmaxOn";
  sx->AddNamedSlot(name);
  sx->SetSignal(-1,name);
  name="dangmaxOff";
  sx->AddNamedSlot(name);
  sx->SetSignal(-1,name);
  name="OmegaOn";
  sx->AddNamedSlot(name);
  sx->SetSignal(0,name);
  name="OmegaOff";
  sx->AddNamedSlot(name);
  sx->SetSignal(0,name);
 
  // Store the On-source and Off-source maximum (solid) angles for this burst
  if (fixedwinset && dangmax>=0)
  {
   if (fDawin<0) // Local zenith band
   {
    thlow=thetagrb-0.5*dangmax;
    thup=thetagrb+0.5*dangmax;
    solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   }
   else // Circle around GRB position
   {
    thlow=0;
    thup=dangmax;
    solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   }
   sx->SetSignal(dangmax,"dangmaxOn");
   sx->SetSignal(solidangle,"OmegaOn");
   sx->SetSignal(dangmax,"dangmaxOff");
   sx->SetSignal(solidangle*float(fNbkg),"OmegaOff");
  }
  else // Initialize the encountered dynamic On-source and Off-source maximum angles for this burst
  {
   dangmaxon=0;
   if (fSumsigmas==0 || fSumsigmas==1 || fSumsigmas==2) dangmaxon=fabs(fDawin*sigmagrb);
   dangmaxoff=dangmaxon;
  }
 
  // Generate the background events in the search time window 
  // for both this GRB angular cone and the corresponding background bkg patch(es)
  for (Int_t bkgpatch=0; bkgpatch<=fNbkg; bkgpatch++)
  {
   nmu=int(fRan->Poisson(fNbkgWin));
   for (Int_t imu=0; imu<nmu; imu++)
   {
    // Obtain a random event time within the search time window
    ranlow=fTmin;
    ranup=fTmax;
    dt=fRan->Uniform(ranlow,ranup);
 
    // Create a random background event within the user selected burst RA and Dec interval
    // and convert to local detector coordinates to allow a local zenith band selection.
    // For the conversion, a single, re-usable temp. reference signal will be created, since measurements may get scrambled when stored.
    thlow=90.-fDeclmax; // Lower theta angle in overall Earth spherical coordinates (North Pole is theta=0)
    thup=90.-fDeclmin;  // Upper theta angle in overall Earth spherical coordinates (North Pole is theta=0)
    RandomPosition(rmu,thlow,thup,fRAmin,fRAmax);
    decmu=90.-rmu.GetX(2,"sph","deg");
    ramu=rmu.GetX(3,"sph","deg");
    tmu=*tx;
    tmu.AddSec(dt*fTfact);
    SetSignal(1,ramu,"deg",decmu,"deg","equ",&tmu,fNgrbs+1,"J","bkgtemp",0);
    GetSignal(dmu,thetamu,"deg",phimu,"deg","loc",&tmu,fNgrbs+1);
    rmu.SetPosition(1,thetamu,phimu,"sph","deg");
 
    if (fDawin<0) // Local zenith band
    {
     dang=fabs(thetagrb-thetamu);
    }
    else // Circle around GRB position
    {
     dang=rgrb.GetOpeningAngle(rmu,"deg");
    }
 
    // Check if event lies outside the allowed angular area
    if (fDatype>=0 && fixedwinset && dang>dangmax) continue;
 
    // The energy of the background signal
    E=GetBurstBackgroundEnergy();
 
    if (E<0 || E<fEmin || E>fEmax) continue;
 
    // The reconstruction angular resolution of the background signal
    sigmareco=GetBurstRecoAngres(E,E);
    if (sigmareco<0) sigmareco=fAngresfix;
 
    if (sigmareco<fAngresmin || sigmareco>fAngresmax) continue;
 
    if (hSigmaReco) hSigmaReco->Fill(sigmareco);
 
    sigmatot=-1;
    if (fSumsigmas==-1) sigmatot=sigmareco;
    if (fSumsigmas==0) sigmatot=sigmagrb;
    if (fSumsigmas==1) sigmatot=sigmagrb+sigmareco;
    if (fSumsigmas==2) sigmatot=sqrt(sigmagrb*sigmagrb+sigmareco*sigmareco);
 
    // Determine the dynamic angular window including the track reco uncertainty
    if (!fixedwinset)
    {
     dangmax=-1;
     if (sigmatot>=0) dangmax=fabs(fDawin*sigmatot);
    }
 
    if (fDatype>=0 && dang>dangmax) continue;
 
    if (!bkgpatch)
    {
     if (dangmax>dangmaxon) dangmaxon=dangmax;
     fBurstOnReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
     fBurstOnMatch.Enter(E,dt,dang,dt/(zgrb+1.));
     fBurstParameters->AddSignal(E,"EnergyOn");
    }
    else
    {
     if (dangmax>dangmaxoff) dangmaxoff=dangmax;
     fBurstOffReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
     fBurstOffMatch.Enter(E,dt,dang,dt/(zgrb+1.));
     fBurstParameters->AddSignal(E,"EnergyOff");
    }
   } // End of loop over the background tracks of this patch
  } // End of loop over the patches
 
  // Generate the GRB related signal event(s) in the search window.
  // The GRB position gets Gaussian smeared to reflect the actual position.
  // The time difference between the gammas and the neutrinos gets corrected
  // for the GRB redshift and smeared by the detector time resolution.
  // The muon direction gets modified to account for the kinematical opening angle
  // w.r.t. the neutrino direction and Gaussian smeared by the detector angular resolution.
 
  // Prevent statistical overfluctuation in number of GRB signal events if requested by fGrbnu<0
  if (fGrbnu>=0 || nmugrb<int(fabs(fGrbnu)*float(fNgrbs)))
  {
   // Obtain actual GRB position
   rgrb2.Load(rgrb);
   SmearPosition(rgrb2,sigmagrb);
 
   nmu=int(fabs(fGrbnu));
   if (!nmu && fRan->Uniform()<fabs(fGrbnu)) nmu=1;
   for (Int_t imu=0; imu<nmu; imu++)
   {
    nmugrb++;
    if (!fInburst) // Neutrino and gamma production decoupled
    {
     if (fDtnus<0) // Sigma in units of T90
     {
      dt=fRan->Gauss(fDtnu,fabs(fDtnus)*t90grb);
     }
     else // Sigma in seconds
     {
      dt=fRan->Gauss(fDtnu,fDtnus);
     }
     dt=dt*(zgrb+1.);
    }
    else // Coupled neutrino and gamma production
    {
     if (fDtnus<0) // Sigma in units of T90
     {
      dt=fRan->Gauss(fDtnu*t90grb,fabs(fDtnus)*t90grb);
     }
     else // Sigma in seconds
     {
      dt=fRan->Gauss(fDtnu*t90grb,fDtnus);
     }
    }
    if (fTimres>0) dt=fRan->Gauss(dt,fTimres);
 
    // Convert dt from seconds to the selected Tunit
    dt=dt/fTfact; 
 
    // The direction of the GRB signal
    rmu.Load(rgrb2);
 
    // The energy of the GRB signal
    E=GetBurstSignalEnergy();
 
    if (hSigE) hSigE->Fill(E);
 
    // Reduce the energy due to the cosmological redshift effect
    if (fEzcor) E=E/(zgrb+1.);
 
    if (hSigEzcor) hSigEzcor->Fill(E);
 
    if (E<0 || E<fEmin || E>fEmax) continue;
 
    // Modification to account for the neutrino-lepton kinematic opening angle
    if (fKinangle>0)
    {
     Int_t mode=fKinangle-1;
     ang=GetNeutrinoAngle(E,"deg",mode);
     if (ang>0) ShiftPosition(rmu,ang);
    }
 
    // Smearing according to the reconstruction angular resolution
    sigmareco=GetBurstRecoAngres(E,E);
    if (sigmareco<0) sigmareco=fAngresfix;
 
    if (sigmareco<fAngresmin || sigmareco>fAngresmax) continue;
 
    if (hSigmaReco) hSigmaReco->Fill(sigmareco);
 
    SmearPosition(rmu,sigmareco);
 
    // Determine angular difference w.r.t. the presumed GRB position
    dang=rgrb.GetOpeningAngle(rmu,"deg");
 
    sigmatot=-1;
    if (fSumsigmas==-1) sigmatot=sigmareco;
    if (fSumsigmas==0) sigmatot=sigmagrb;
    if (fSumsigmas==1) sigmatot=sigmagrb+sigmareco;
    if (fSumsigmas==2) sigmatot=sqrt(sigmagrb*sigmagrb+sigmareco*sigmareco);
 
    // Determine the dynamic angular window including the track reco uncertainty
    if (!fixedwinset)
    {
     dangmax=-1;
     if (sigmatot>=0) dangmax=fabs(fDawin*sigmatot);
    }
 
    if (fDatype>=0 && dang>dangmax) continue;
 
    if (dangmax>dangmaxon) dangmaxon=dangmax;
    fBurstOnReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
    fBurstOnMatch.Enter(E,dt,dang,dt/(zgrb+1.));
    fBurstSigReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
    fBurstSignal.Enter(E,dt,dang,dt/(zgrb+1.));
    fBurstParameters->AddSignal(E,"EnergyOn");
    fBurstParameters->AddSignal(E,"EnergySig");
   }
  } // End of loop over the signal events of this burst
 
  if (fixedwinset) continue;
 
  // Store the dynamic On-source and Off-source maximum (solid) angles that are encountered for this burst
  if (fDawin<0) // Local zenith band
  {
   thlow=thetagrb-0.5*dangmaxon;
   thup=thetagrb+0.5*dangmaxon;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   sx->SetSignal(dangmaxon,"dangmaxOn");
   sx->SetSignal(solidangle,"OmegaOn");
   thlow=thetagrb-0.5*dangmaxoff;
   thup=thetagrb+0.5*dangmaxoff;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   sx->SetSignal(dangmaxoff,"dangmaxOff");
   sx->SetSignal(solidangle*float(fNbkg),"OmegaOff");
  }
  else // Circle around GRB position
  {
   thlow=0;
   thup=dangmaxon;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   sx->SetSignal(solidangle,"OmegaOn");
   sx->SetSignal(dangmaxon,"dangmaxOn");
   thup=dangmaxoff;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
   sx->SetSignal(dangmaxoff,"dangmaxOff");
   sx->SetSignal(solidangle*float(fNbkg),"OmegaOff");
  }
 } // End of loop over the individual GRBs
 
 // Remove the temporary storage of the background event
 if (fNgrbs>0) RemoveSignal(fNgrbs+1,0,0);
 
 // Compensate statistical underfluctuation in number of GRB signal events if requested by fGrbnu<0
 if (fGrbnu<0) BurstCompensate(nmugrb);
 
 // Determine the On-source and Off-source total stacked solid angles that have been encountered
 name="SolidangleOn";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(0,name);
 name="SolidangleOff";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(0,name);
 for (Int_t igrb=1; igrb<=fNgrbs; igrb++)
 {
  sx=GetSignal(igrb);
 
  if (!sx) continue;
 
  solidangle=sx->GetSignal("OmegaOn");
  fBurstParameters->AddSignal(solidangle,"SolidangleOn");
  solidangle=sx->GetSignal("OmegaOff");
  fBurstParameters->AddSignal(solidangle,"SolidangleOff");
 }
 
 // Determine and list the burst statistics
 MakeBurstDataStats(0,nmugrb);
}

void NcAstrolab::MakeBurstDataStats(Int_t mode,Int_t nmugrb)
{
 
 Double_t pi=acos(-1.);
 
 // Retrieve the needed parameters
 Int_t fNgrbs=TMath::Nint(fBurstParameters->GetSignal("Ngrbs"));
 Int_t fNbkg=TMath::Nint(fBurstParameters->GetSignal("Nbkg"));
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 Float_t fTfact=fBurstParameters->GetSignal("Tfact");
 Float_t fTmin=fBurstParameters->GetSignal("Tmin");
 Float_t fTmax=fBurstParameters->GetSignal("Tmax");
 Int_t fTbint90=TMath::Nint(fBurstParameters->GetSignal("Tbint90"));
 Float_t fTbin=fBurstParameters->GetSignal("Tbin");
 Float_t fVarTbin=fBurstParameters->GetSignal("VarTbin");
 Float_t fAbin=fBurstParameters->GetSignal("Abin");
 Float_t fAvgrbz=fBurstParameters->GetSignal("Avgrbz");
 Float_t fAvgrbt90=fBurstParameters->GetSignal("Avgrbt90");
 Float_t fRbkgDecl=fBurstParameters->GetSignal("RbkgDecl");
 Float_t fSolidangleOn=fBurstParameters->GetSignal("SolidangleOn");
 Float_t fSolidangleOff=fBurstParameters->GetSignal("SolidangleOff");
 Float_t fEnergyOn=fBurstParameters->GetSignal("EnergyOn");
 Float_t fEnergyOff=fBurstParameters->GetSignal("EnergyOff");
 Float_t fEnergySig=fBurstParameters->GetSignal("EnergySig");
 Float_t fEnergyBkg=fEnergyOn-fEnergySig;
 Float_t fSensarea=fBurstParameters->GetSignal("Sensarea");
 
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 Int_t non=fBurstOnMatch.GetN();
 Int_t noff=fBurstOffMatch.GetN();
 Int_t nsig=fBurstSignal.GetN();
 Double_t TminOn=fTmin;
 Double_t TmaxOn=fTmax;
 Double_t TminOff=fTmin;
 Double_t TmaxOff=fTmax;
 
 if (fTmax<=fTmin)
 {
  TminOn=fBurstOnMatch.GetMinimum("dtime");
  TmaxOn=fBurstOnMatch.GetMaximum("dtime");
  TminOff=fBurstOffMatch.GetMinimum("dtime");
  TmaxOff=fBurstOffMatch.GetMaximum("dtime");
 }
 
 Double_t AminOn=fBurstOnMatch.GetMinimum("dang");
 Double_t AmaxOn=fBurstOnMatch.GetMaximum("dang");
 Double_t AminOff=fBurstOffMatch.GetMinimum("dang");
 Double_t AmaxOff=fBurstOffMatch.GetMaximum("dang");
 
 // Update the time window sizes and the average number of background events in them
 Float_t DtwinOn=TmaxOn-TminOn;
 Float_t DtwinOff=TmaxOff-TminOff;
 Float_t NbkgWinOn=fRbkgDecl*DtwinOn*fTfact;
 Float_t NbkgWinOff=fRbkgDecl*DtwinOff*fTfact;
 
 TString title;
 TString name;
 TString s;
 Float_t xmin=0;
 Float_t xmax=0;
 TAxis* axis=0;
 Int_t nbins=0;
 Double_t binsize=0;
 Double_t binsizecos=0;
 Int_t nabinsOn=0;
 Double_t abinsizeOn=0;
 Int_t nabinsOff=0;
 Double_t abinsizeOff=0;
 
 // The source redshift, position and reconstruction uncertainty histograms
 TH1F* hOnSourceZ=0;
 TH1F* hOffSourceZ=0;
 TH1F* hOnSigSourceZ=0;
 TH1F* hOnSigmaSource=0;
 TH1F* hOffSigmaSource=0;
 TH1F* hOnSigSigmaSource=0;
 TH1F* hOnSigmaReco=0;
 TH1F* hOffSigmaReco=0;
 TH1F* hOnSigSigmaReco=0;
 TH1F* hOnSigmaComb=0;
 TH1F* hOffSigmaComb=0;
 TH1F* hOnSigSigmaComb=0;
 nbins=100;
 if (fBurstOnReco.GetN())
 {
  title.Form("On-Source object redshifts with matching event(s);Redshift;Counts");
  hOnSourceZ=new TH1F("hOnSourceZ",title,nbins,1,0);
  hOnSourceZ->SetBuffer(non);
 
  title.Form("On-Source object position uncertainties with matching event(s);Object position angular uncertainty (sigma in degrees);Counts");
  hOnSigmaSource=new TH1F("hOnSigmaSource",title,nbins,1,0);
  hOnSigmaSource->SetBuffer(non);
 
  title.Form("On-source event reconstruction uncertainties in the final sample;Event angular reconstruction uncertainty (sigma in degrees);Counts");
  hOnSigmaReco=new TH1F("hOnSigmaReco",title,nbins,1,0);
  hOnSigmaReco->SetBuffer(non);
 
  title.Form("On-source combined object position and event reconstruction uncertainty;Combined object position and event reco angular uncertainty (sigma in degrees);Counts");
  hOnSigmaComb=new TH1F("hOnSigmaComb",title,nbins,1,0);
  hOnSigmaComb->SetBuffer(non);
 }
 
 if (fBurstOffReco.GetN())
 {
  title.Form("Off-Source object redshifts with matching event(s);Redshift;Counts");
  hOffSourceZ=new TH1F("hOffSourceZ",title,nbins,1,0);
  hOffSourceZ->SetBuffer(noff);
 
  title.Form("Off-Source object position uncertainties with matching event(s);Object position angular uncertainty (sigma in degrees);Counts");
  hOffSigmaSource=new TH1F("hOffSigmaSource",title,nbins,1,0);
  hOffSigmaSource->SetBuffer(noff);
 
  title.Form("Off-source event reconstruction uncertainties in the final sample;Event angular reconstruction uncertainty (sigma in degrees);Counts");
  hOffSigmaReco=new TH1F("hOffSigmaReco",title,nbins,1,0);
  hOffSigmaReco->SetBuffer(noff);
 
  title.Form("Off-source combined object position and event reconstruction uncertainty;Combined object position and event reco angular uncertainty (sigma in degrees);Counts");
  hOffSigmaComb=new TH1F("hOffSigmaComb",title,nbins,1,0);
  hOffSigmaComb->SetBuffer(noff);
 }
 
 if (fBurstSigReco.GetN())
 {
  title.Form("On-Source object redshifts with matching simulated signal event(s);Redshift;Counts");
  hOnSigSourceZ=new TH1F("hOnSigSourceZ",title,nbins,1,0);
  hOnSigSourceZ->SetBuffer(nsig);
 
  title.Form("On-Source object position uncertainties with matching simulated signal event(s);Object position angular uncertainty (sigma in degrees);Counts");
  hOnSigSigmaSource=new TH1F("hOnSigSigmaSource",title,nbins,1,0);
  hOnSigSigmaSource->SetBuffer(nsig);
 
  title.Form("On-source simulated signal event reconstruction uncertainties in the final sample;Event angular reconstruction uncertainty (sigma in degrees);Counts");
  hOnSigSigmaReco=new TH1F("hOnSigSigmaReco",title,nbins,1,0);
  hOnSigSigmaReco->SetBuffer(nsig);
 
  title.Form("On-source combined object position and simulated signal event reconstruction uncertainty;Combined object position and event reco angular uncertainty (sigma in degrees);Counts");
  hOnSigSigmaComb=new TH1F("hOnSigSigmaComb",title,nbins,1,0);
  hOnSigSigmaComb->SetBuffer(nsig);
 }
 
 // The energy histograms
 TH1F* hOnE=0;
 TH1F* hOffE=0;
 TH1F* hOnSigE=0;
 nbins=1000;
 if (non)
 {
  title.Form("On-source reconstructed event energy in the final sample;Event energy in GeV;Counts");
  if (!mode) title.ReplaceAll("reconstructed","simulated");
  hOnE=new TH1F("hOnE",title,nbins,1,0);
 }
 if (noff)
 {
  title.Form("Off-source reconstructed event energy in the final sample;Event energy in GeV;Counts");
  if (!mode) title.ReplaceAll("reconstructed","simulated");
  hOffE=new TH1F("hOffE",title,nbins,1,0);
 }
 if (nsig)
 {
  title.Form("On-source simulated signal event energy in the final sample;Event energy in GeV;Counts");
  hOnSigE=new TH1F("hOnSigE",title,nbins,1,0);
 }
 
 // Additional text for histo titles to indicate scrambling of the corresponding data
 TString scrt=""; // Time scrambling
 TString scrp=""; // Position scrambling
 if (fTscmode>0) scrt="(scrambled)";
 if (fRscmode>0 || fTscmode==3) scrp="(scrambled)";
 
 // Create the angular separation histograms
 TH1F* hOna=0;
 TH1F* hOffa=0;
 TH1F* hOnSiga=0;
 TH1F* hOnCosa=0;
 TH1F* hOffCosa=0;
 TH1F* hOnSigcosa=0;
 if (non && fAbin)
 {
  if (fAbin>0)
  {
   binsize=fAbin;
   nbins=int((AmaxOn-AminOn)/binsize);
  }
  else
  {
   nbins=int(((AmaxOn-AminOn)/180.)*NbkgWinOn*float(fNgrbs)/fabs(fAbin));
   if (nbins) binsize=(AmaxOn-AminOn)/float(nbins);
  }
  if (nbins)
  {
   title.Form("Reconstructed %-s opening angle of on-source events in time window;Opening angle (degrees);Counts per %-.3g degrees",scrp.Data(),binsize);
   hOna=new TH1F("hOna",title,nbins+1,AminOn,AmaxOn+binsize);
  }
  else
  {
   nbins=100;
   binsize=AmaxOn/float(nbins);
   title.Form("Reconstructed %-s opening angle of on-source events in time window;Opening angle (degrees);Counts per %-.3g degrees",scrp.Data(),binsize);
   hOna=new TH1F("hOna",title,nbins+2,AminOn-binsize,AmaxOn+binsize);
  }
  nabinsOn=nbins;
  abinsizeOn=binsize;
  if (nbins) binsizecos=(cos(AminOn*pi/180.)-cos(AmaxOn*pi/180.))/float(nbins);
  if (binsizecos>0)
  {
   title.Form("Reconstructed %-s cos(opening angle) of on-source events in time window;cos(opening angle);Counts per %-.3g",scrp.Data(),binsizecos);
   hOnCosa=new TH1F("hOnCosa",title,nbins+1,cos(AmaxOn*pi/180.),cos(AminOn*pi/180.)+binsizecos);
  }
  else
  {
   nbins=100;
   binsizecos=fabs(cos(AmaxOn*pi/180.))/float(nbins);
   title.Form("Reconstructed %-s cos(opening angle) of on-source events in time window;cos(opening angle);Counts per %-.3g",scrp.Data(),binsizecos);
   hOnCosa=new TH1F("hOnCosa",title,nbins+2,cos(AmaxOn*pi/180.)-binsizecos,cos(AminOn*pi/180.)+binsizecos);
  }
 }
 if (nsig && nbins)
 {
  title.Form("Reconstructed opening angle of on-source simulated signal events in time window;Opening angle (degrees);Counts per %-.3g degrees",binsize);
  hOnSiga=new TH1F("hOnSiga",title,nbins+2,AminOn-binsize,AmaxOn+binsize);
  title.Form("Reconstructed cos(opening angle) of on-source simulated signal events in time window;cos(opening angle);Counts per %-.3g",binsizecos);
  hOnSigcosa=new TH1F("hOnSigcosa",title,nbins+2,cos(AmaxOn*pi/180.)-binsizecos,cos(AminOn*pi/180.)+binsizecos);
 }
 nbins=0;
 binsize=0;
 binsizecos=0;
 if (noff && fAbin)
 {
  if (fAbin>0)
  {
   binsize=fAbin;
   nbins=int((AmaxOff-AminOff)/binsize);
  }
  else
  {
   nbins=int(((AmaxOff-AminOff)/180.)*NbkgWinOff*float(fNgrbs)*float(fNbkg)/fabs(fAbin));
   if (nbins) binsize=(AmaxOff-AminOff)/float(nbins);
  }
  if (nbins)
  {
   title.Form("Reconstructed opening angle of off-source events in time window;Opening angle (degrees);Counts per %-.3g degrees",binsize);
   hOffa=new TH1F("hOffa",title,nbins+1,AminOff,AmaxOff+binsize);
  }
  else
  {
   nbins=100;
   binsize=AmaxOff/float(nbins);
   title.Form("Reconstructed opening angle of off-source events in time window;Opening angle (degrees);Counts per %-.3g degrees",binsize);
   hOffa=new TH1F("hOffa",title,nbins+2,AminOff-binsize,AmaxOff+binsize);
  }
  nabinsOff=nbins;
  abinsizeOff=binsize;
  if (nbins) binsizecos=(cos(AminOff*pi/180.)-cos(AmaxOff*pi/180.))/float(nbins);
  if (binsizecos>0)
  {
   title.Form("Reconstructed cos(opening angle) of off-source events in time window;cos(opening angle);Counts per %-.3g",binsizecos);
   hOffCosa=new TH1F("hOffCosa",title,nbins+1,cos(AmaxOff*pi/180.),cos(AminOff*pi/180.)+binsizecos);
  }
  else
  {
   nbins=100;
   binsizecos=fabs(cos(AmaxOff*pi/180.))/float(nbins);
   title.Form("Reconstructed cos(opening angle) of off-source events in time window;cos(opening angle);Counts per %-.3g",binsizecos);
   hOffCosa=new TH1F("hOffCosa",title,nbins+2,cos(AmaxOff*pi/180.)-binsizecos,cos(AminOff*pi/180.)+binsizecos);
  }
 }
 
 // Create the arrival time histograms
 TH1F* hOnt=0;
 TH1F* hOfft=0;
 TH1F* hOnSigt=0;
 TH2F* hOnta=0;
 TH2F* hOffta=0;
 TH2F* hOnSigta=0;
 TH2F* hOnZta=0;
 TH2F* hOffZta=0;
 TH2F* hOnSigZta=0;
 
 // The redshift corrected arrival time histograms
 TH1F* hOnZt=0;
 TH1F* hOffZt=0;
 TH1F* hOnSigZt=0;
 
 nbins=0;
 binsize=0;
 TString addtitle;
 addtitle.Form(" (=%-g*<T90>)",fTbin);
 if (fTbin<0) addtitle.Form(" (~%-g counts/bin)",fabs(fTbin));
 if (fabs(fTbin)>0) // Fixed time bins
 {
  // Automatic time binning to get the specified maximal bkg counts per bin
  nbins=int(NbkgWinOn*float(fNgrbs)/fabs(fTbin));
  Int_t temp=int(NbkgWinOff*float(fNgrbs)*float(fNbkg)/fabs(fTbin));
  if (temp>nbins) nbins=temp;
  if (nbins) binsize=DtwinOn/float(nbins);
 
  if (fTbin>0) // User defined time bin size
  {
   binsize=fTbin;
   if (fTbint90) binsize=fTbin*fabs(fAvgrbt90)/fTfact;
   nbins=DtwinOn/binsize;
  }
  if (nbins && non)
  {
   title.Form("Arrival times %-s of on-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",scrt.Data(),tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOnt=new TH1F("hOnt",title,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Arrival time %-s vs. reconstructed %-s opening angle of on-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",scrt.Data(),scrp.Data(),tu.Data());
   hOnta=new TH2F("hOnta",title,nabinsOn+2,AminOn-abinsizeOn,AmaxOn+abinsizeOn,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Redshift corrected arrival times %-s of on-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",scrt.Data(),tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOnZt=new TH1F("hOnZt",title,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Redshift corrected %-s arrival time vs. reconstructed %-s opening angle of on-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",scrt.Data(),scrp.Data(),tu.Data());
   hOnZta=new TH2F("hOnZta",title,nabinsOn+2,AminOn-abinsizeOn,AmaxOn+abinsizeOn,nbins+2,TminOn-binsize,TmaxOn+binsize);
  }
  if (nbins && nsig)
  {
   title.Form("Arrival times of on-source simulated signal events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOnSigt=new TH1F("hOnSigt",title,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Arrival time vs. reconstructed opening angle of on-source simulated signal events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
   hOnSigta=new TH2F("hOnSigta",title,nabinsOn+2,AminOn-abinsizeOn,AmaxOn+abinsizeOn,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Redshift corrected arrival times of on-source simulated signal events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOnSigZt=new TH1F("hOnSigZt",title,nbins+2,TminOn-binsize,TmaxOn+binsize);
   title.Form("Redshift corrected arrival time vs. reconstructed opening angle of on-source simulated signal events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
   hOnSigZta=new TH2F("hOnSigZta",title,nabinsOn+2,AminOn-abinsizeOn,AmaxOn+abinsizeOn,nbins+2,TminOn-binsize,TmaxOn+binsize);
  }
 
  if (fTbin>0) // User defined time bin size
  {
   binsize=fTbin;
   if (fTbint90) binsize=fTbin*fabs(fAvgrbt90)/fTfact;
   nbins=DtwinOff/binsize;
  }
  if (nbins && noff)
  {
   title.Form("Arrival times of off-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOfft=new TH1F("hOfft",title,nbins+2,TminOff-binsize,TmaxOff+binsize);
   title.Form("Arrival time vs. reconstructed opening angle of off-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
   hOffta=new TH2F("hOffta",title,nabinsOff+2,AminOff-abinsizeOff,AmaxOff+abinsizeOff,nbins+2,TminOff-binsize,TmaxOff+binsize);
   title.Form("Redshift corrected arrival times of off-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per %-.3g %-s",tu.Data(),binsize,tu.Data());
   if (fTbint90 || fTbin<0) title+=addtitle;
   hOffZt=new TH1F("hOffZt",title,nbins+2,TminOff-binsize,TmaxOff+binsize);
   title.Form("Redshift corrected arrival time vs. reconstructed opening angle of off-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
   hOffZta=new TH2F("hOffZta",title,nabinsOff+2,AminOff-abinsizeOff,AmaxOff+abinsizeOff,nbins+2,TminOff-binsize,TmaxOff+binsize);
  }
 }
 else // Variable time bins
 {
  Double_t* binarr=0;
  Int_t nbx=int(DtwinOn/fVarTbin);
  Float_t gamma=fabs(fAvgrbz)+1.;
  Float_t* bins=new Float_t[nbx];
  nbins=0;
  Float_t xlow=0,xup=0,size=fVarTbin;
  for (Int_t i=0; i<nbx-1; i++)
  {
   xup=xlow+size;
   if (xup>DtwinOn/2.) // Store the last lowerbound
   {
    bins[i]=xlow;
    nbins++;
    break;
   }
   bins[i]=xlow;
   nbins++;
   xlow=xup;
   size=xlow*gamma;
  }
  binarr=new Double_t[2*nbins-1];
  for (Int_t j=nbins; j>0; j--)
  {
   binarr[nbins-j]=-bins[j-1];
   binarr[nbins+j-2]=bins[j-1];
  }
  nbins=2*nbins-2;
  if (nbins && non)
  {
   title.Form("Arrival times %-s of on-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per time bin",scrt.Data(),tu.Data());
   hOnt=new TH1F("hOnt",title,nbins,binarr);
   if (nabinsOn)
   {
    title.Form("Arrival time %-s vs. reconstructed %-s opening angle of on-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",scrt.Data(),scrp.Data(),tu.Data());
    hOnta=new TH2F("hOnta",title,nabinsOn,AminOn,AmaxOn,nbins,binarr);
   }
  }
  if (nbins && noff)
  {
   title.Form("Arrival times of off-source events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per time bin",tu.Data());
   hOfft=new TH1F("hOfft",title,nbins,binarr);
   if (nabinsOff)
   {
    title.Form("Arrival time vs. reconstructed opening angle of off-source events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
    hOffta=new TH2F("hOffta",title,nabinsOff,AminOff,AmaxOff,nbins,binarr);
   }
  }
  if (nbins && nsig)
  {
   title.Form("Arrival times of on-source simulated signal events in time window;Event arrival time (in %-s) w.r.t. burst trigger;Counts per time bin",tu.Data());
   hOnSigt=new TH1F("hOnSigt",title,nbins,binarr);
   if (nabinsOn)
   {
    title.Form("Arrival time vs. reconstructed opening angle of on-source simulated signal events in time window;Opening angle (degrees);Event arrival time (in %-s) w.r.t. burst trigger",tu.Data());
    hOnSigta=new TH2F("hOnSigta",title,nabinsOn,AminOn,AmaxOn,nbins,binarr);
   }
  }
 
  delete[] binarr;
 }
 
 // Fill the histograms
 Double_t value1=0;
 Double_t value2=0;
 Double_t value3=0;
 Double_t value4=0;
 
 // The on-source data
 for (Int_t i=1; i<=fBurstOnReco.GetN(); i++)
 {
  value1=fBurstOnReco.GetEntry(i,"zburst");
  value2=fBurstOnReco.GetEntry(i,"sigmaburst");
  value3=fBurstOnReco.GetEntry(i,"sigmareco");
  value4=fBurstOnReco.GetEntry(i,"sigmacomb");
  if (hOnSourceZ) hOnSourceZ->Fill(value1);
  if (hOnSigmaSource) hOnSigmaSource->Fill(value2);
  if (hOnSigmaReco) hOnSigmaReco->Fill(value3);
  if (hOnSigmaComb) hOnSigmaComb->Fill(value4);
 }
 
 for (Int_t i=1; i<=fBurstOnMatch.GetN(); i++)
 {
  value1=fBurstOnMatch.GetEntry(i,"E");
  value2=fBurstOnMatch.GetEntry(i,"dang");
  value3=fBurstOnMatch.GetEntry(i,"dtime");
  value4=fBurstOnMatch.GetEntry(i,"dtimez");
  if (hOnE) hOnE->Fill(value1);
  if (hOna) hOna->Fill(value2);
  if (hOnCosa) hOnCosa->Fill(cos(value2*pi/180.));
  if (hOnt) hOnt->Fill(value3);
  if (hOnta) hOnta->Fill(value2,value3);
  if (hOnZt) hOnZt->Fill(value4);
  if (hOnZta) hOnZta->Fill(value2,value4);
 }
 
 // The off-source data
 for (Int_t i=1; i<=fBurstOffReco.GetN(); i++)
 {
  value1=fBurstOffReco.GetEntry(i,"zburst");
  value2=fBurstOffReco.GetEntry(i,"sigmaburst");
  value3=fBurstOffReco.GetEntry(i,"sigmareco");
  value4=fBurstOffReco.GetEntry(i,"sigmacomb");
  if (hOffSourceZ) hOffSourceZ->Fill(value1);
  if (hOffSigmaSource) hOffSigmaSource->Fill(value2);
  if (hOffSigmaReco) hOffSigmaReco->Fill(value3);
  if (hOffSigmaComb) hOffSigmaComb->Fill(value4);
 }
 
 for (Int_t i=1; i<=fBurstOffMatch.GetN(); i++)
 {
  value1=fBurstOffMatch.GetEntry(i,"E");
  value2=fBurstOffMatch.GetEntry(i,"dang");
  value3=fBurstOffMatch.GetEntry(i,"dtime");
  value4=fBurstOffMatch.GetEntry(i,"dtimez");
  if (hOffE) hOffE->Fill(value1);
  if (hOffa) hOffa->Fill(value2);
  if (hOffCosa) hOffCosa->Fill(cos(value2*pi/180.));
  if (hOfft) hOfft->Fill(value3);
  if (hOffta) hOffta->Fill(value2,value3);
  if (hOffZt) hOffZt->Fill(value4);
  if (hOffZta) hOffZta->Fill(value2,value4);
 }
 
 // The simulated signal data
 for (Int_t i=1; i<=fBurstSigReco.GetN(); i++)
 {
  value1=fBurstSigReco.GetEntry(i,"zburst");
  value2=fBurstSigReco.GetEntry(i,"sigmaburst");
  value3=fBurstSigReco.GetEntry(i,"sigmareco");
  value4=fBurstSigReco.GetEntry(i,"sigmacomb");
  if (hOnSigSourceZ) hOnSigSourceZ->Fill(value1);
  if (hOnSigSigmaSource) hOnSigSigmaSource->Fill(value2);
  if (hOnSigSigmaReco) hOnSigSigmaReco->Fill(value3);
  if (hOnSigSigmaComb) hOnSigSigmaComb->Fill(value4);
 }
 
 for (Int_t i=1; i<=fBurstSignal.GetN(); i++)
 {
  value1=fBurstSignal.GetEntry(i,"E");
  value2=fBurstSignal.GetEntry(i,"dang");
  value3=fBurstSignal.GetEntry(i,"dtime");
  value4=fBurstSignal.GetEntry(i,"dtimez");
  if (hOnSigE) hOnSigE->Fill(value1);
  if (hOnSiga) hOnSiga->Fill(value2);
  if (hOnSigcosa) hOnSigcosa->Fill(cos(value2*pi/180.));
  if (hOnSigt) hOnSigt->Fill(value3);
  if (hOnSigta) hOnSigta->Fill(value2,value3);
  if (hOnSigZt) hOnSigZt->Fill(value4);
  if (hOnSigZta) hOnSigZta->Fill(value2,value4);
 }
 
 // Bayesian block analysis of the arrival times
 NcBlocks BB;
 TH1F hOnBBt;
 TH1F hOnBBzt;
 if (fBurstOnMatch.GetN())
 {
  BB.GetBlocks(fBurstOnMatch,"dtime",0.05,&hOnBBt);
  title.Form("Bayesian blocks for on-source arrival times %-s;Event arrival time (in %-s) w.r.t. burst trigger;Event rate (%-s^{-1}) for %-i stacked time windows",scrt.Data(),tu.Data(),tu.Data(),fNgrbs);
  title.ReplaceAll("days^","day^");
  title.ReplaceAll("hours^","hour^");
  hOnBBt.SetNameTitle("hOnBBt",title);
  BB.GetBlocks(fBurstOnMatch,"dtimez",0.05,&hOnBBzt);
  title.Form("Bayesian blocks for redshift corrected on-source arrival times %-s;Event arrival time (in %-s) w.r.t. burst trigger;Event rate (%-s^{-1}) for %-i stacked time windows",scrt.Data(),tu.Data(),tu.Data(),fNgrbs);
  title.ReplaceAll("days^","day^");
  title.ReplaceAll("hours^","hour^");
  hOnBBzt.SetNameTitle("hOnBBzt",title);
 }
 TH1F hOffBBt;
 TH1F hOffBBzt;
 if (fBurstOffMatch.GetN())
 {
  BB.GetBlocks(fBurstOffMatch,"dtime",0.05,&hOffBBt);
  title.Form("Bayesian blocks for off-source arrival times;Event arrival time (in %-s) w.r.t. burst trigger;Event rate (%-s^{-1}) for %-i stacked time windows",tu.Data(),tu.Data(),fNgrbs*fNbkg);
  title.ReplaceAll("days^","day^");
  title.ReplaceAll("hours^","hour^");
  hOffBBt.SetNameTitle("hOffBBt",title);
  BB.GetBlocks(fBurstOffMatch,"dtimez",0.05,&hOffBBzt);
  title.Form("Bayesian blocks for redshift corrected off-source arrival times;Event arrival time (in %-s) w.r.t. burst trigger;Event rate (%-s^{-1}) for %-i stacked time windows",tu.Data(),tu.Data(),fNgrbs*fNbkg);
  title.ReplaceAll("days^","day^");
  title.ReplaceAll("hours^","hour^");
  hOffBBzt.SetNameTitle("hOffBBzt",title);
 }
 
 // Ratio On/Off for the Bayesian Block histograms
 Float_t temp=0;
 Int_t nb1=0;
 Int_t nb2=0;
 
 axis=hOnBBt.GetXaxis();
 xmin=axis->GetXmin();
 xmax=axis->GetXmax();
 axis=hOffBBt.GetXaxis();
 temp=axis->GetXmin();
 if (temp<xmin) xmin=temp;
 temp=axis->GetXmax();
 if (temp>xmax) xmax=temp;
 
 TH1F hOnUBBt;
 TH1F hOffUBBt;
 TH1F hRatUBBt;
 title.Form("Event rate (%-s^{-1}) scaled per time window",tu.Data());
 title.ReplaceAll("days^","day^");
 title.ReplaceAll("hours^","hour^");
 nb1=BB.Rebin(&hOnBBt,&hOnUBBt,kFALSE,0,xmin,xmax);
 nb2=BB.Rebin(&hOffBBt,&hOffUBBt,kFALSE,0,xmin,xmax);
 if (nb2>nb1) BB.Rebin(&hOnBBt,&hOnUBBt,kFALSE,nb2,xmin,xmax);
 hOnUBBt.SetName("hOnUBBt");
 hOffUBBt.SetName("hOffUBBt");
 if (fNgrbs>1) hOnUBBt.Scale(1./float(fNgrbs));
 if (fNgrbs*fNbkg>1) hOffUBBt.Scale(1./float(fNgrbs*fNbkg));
 hOnUBBt.SetYTitle(title);
 hOffUBBt.SetYTitle(title);
 BB.Divide(&hOnUBBt,&hOffUBBt,&hRatUBBt,kFALSE,1);
 hRatUBBt.SetName("hRatUBBt");
 hRatUBBt.SetYTitle("Ratio");
 
 nbins=hOnBBzt.GetNbinsX();
 if (hOffBBzt.GetNbinsX()>nbins) nbins=hOffBBzt.GetNbinsX();
 axis=hOnBBzt.GetXaxis();
 xmin=axis->GetXmin();
 xmax=axis->GetXmax();
 axis=hOffBBzt.GetXaxis();
 temp=axis->GetXmin();
 if (temp<xmin) xmin=temp;
 temp=axis->GetXmax();
 if (temp>xmax) xmax=temp;
 
 TH1F hOnUBBzt;
 TH1F hOffUBBzt;
 TH1F hRatUBBzt;
 nb1=BB.Rebin(&hOnBBzt,&hOnUBBzt,kFALSE,0,xmin,xmax);
 nb2=BB.Rebin(&hOffBBzt,&hOffUBBzt,kFALSE,0,xmin,xmax);
 if (nb2>nb1) BB.Rebin(&hOnBBzt,&hOnUBBzt,kFALSE,nb2,xmin,xmax);
 hOnUBBzt.SetName("hOnUBBzt");
 hOffUBBzt.SetName("hOffUBBzt");
 if (fNgrbs>1) hOnUBBzt.Scale(1./float(fNgrbs));
 if (fNgrbs*fNbkg>1) hOffUBBzt.Scale(1./float(fNgrbs*fNbkg));
 hOnUBBzt.SetYTitle(title);
 hOffUBBzt.SetYTitle(title);
 BB.Divide(&hOnUBBzt,&hOffUBBzt,&hRatUBBzt,kFALSE,1);
 hRatUBBzt.SetName("hRatUBBzt");
 hRatUBBzt.SetYTitle("Ratio");
 
 // Store the produced histograms
 if (hOnSourceZ) fBurstHistos.Add(hOnSourceZ);
 if (hOffSourceZ) fBurstHistos.Add(hOffSourceZ);
 if (hOnSigSourceZ) fBurstHistos.Add(hOnSigSourceZ);
 if (hOnSigmaSource) fBurstHistos.Add(hOnSigmaSource);
 if (hOffSigmaSource) fBurstHistos.Add(hOffSigmaSource);
 if (hOnSigSigmaSource) fBurstHistos.Add(hOnSigSigmaSource);
 if (hOnSigmaReco) fBurstHistos.Add(hOnSigmaReco);
 if (hOffSigmaReco) fBurstHistos.Add(hOffSigmaReco);
 if (hOnSigSigmaReco) fBurstHistos.Add(hOnSigSigmaReco);
 if (hOnSigmaComb) fBurstHistos.Add(hOnSigmaComb);
 if (hOffSigmaComb) fBurstHistos.Add(hOffSigmaComb);
 if (hOnSigSigmaComb) fBurstHistos.Add(hOnSigSigmaComb);
 if (hOnE) fBurstHistos.Add(hOnE);
 if (hOffE) fBurstHistos.Add(hOffE);
 if (hOnSigE) fBurstHistos.Add(hOnSigE);
 if (hOna) fBurstHistos.Add(hOna);
 if (hOffa) fBurstHistos.Add(hOffa);
 if (hOnSiga) fBurstHistos.Add(hOnSiga);
 if (hOnCosa) fBurstHistos.Add(hOnCosa);
 if (hOffCosa) fBurstHistos.Add(hOffCosa);
 if (hOnSigcosa) fBurstHistos.Add(hOnSigcosa);
 if (hOnt) fBurstHistos.Add(hOnt);
 if (hOfft) fBurstHistos.Add(hOfft);
 if (hOnSigt) fBurstHistos.Add(hOnSigt);
 if (hOnta) fBurstHistos.Add(hOnta);
 if (hOffta) fBurstHistos.Add(hOffta);
 if (hOnSigta)fBurstHistos.Add(hOnSigta);
 if (hOnt && hOnBBt.GetEntries()) fBurstHistos.Add(hOnBBt.Clone());
 if (hOfft && hOffBBt.GetEntries()) fBurstHistos.Add(hOffBBt.Clone());
 if (hOnt && hOnUBBt.GetEntries()) fBurstHistos.Add(hOnUBBt.Clone());
 if (hOfft && hOffUBBt.GetEntries()) fBurstHistos.Add(hOffUBBt.Clone());
 if (hOnt && hOfft && hRatUBBt.GetEntries()) fBurstHistos.Add(hRatUBBt.Clone());
 if (hOnZt) fBurstHistos.Add(hOnZt);
 if (hOffZt) fBurstHistos.Add(hOffZt);
 if (hOnSigZt) fBurstHistos.Add(hOnSigZt);
 if (hOnZta) fBurstHistos.Add(hOnZta);
 if (hOffZta) fBurstHistos.Add(hOffZta);
 if (hOnSigZta) fBurstHistos.Add(hOnSigZta);
 if (hOnZt && hOnBBzt.GetEntries()) fBurstHistos.Add(hOnBBzt.Clone());
 if (hOffZt && hOffBBzt.GetEntries()) fBurstHistos.Add(hOffBBzt.Clone());
 if (hOnZt && hOnUBBzt.GetEntries()) fBurstHistos.Add(hOnUBBzt.Clone());
 if (hOffZt && hOffUBBzt.GetEntries()) fBurstHistos.Add(hOffUBBzt.Clone());
 if (hOnZt && hOffZt && hRatUBBzt.GetEntries()) fBurstHistos.Add(hRatUBBzt.Clone());
 
 // Make sure that also the auto-binned histograms have their axes ranges set
 Int_t nh=fBurstHistos.GetEntries();
 for (Int_t ih=0; ih<nh; ih++)
 {
  TH1* hx=(TH1*)fBurstHistos.At(ih);
  if (!hx) continue;
  hx->BufferEmpty(1);
 
  name=hx->GetName();
 
  if (name=="hTdiff")
  {
   binsize=hx->GetBinWidth(1);
   s.Form("Counts per %-.3g %-s",binsize,tu.Data());
   axis=hx->GetYaxis();
   if (axis) axis->SetTitle(s);
  }
 
  if (name=="hAdiff" || name.Contains("Sigma"))
  {
   binsize=hx->GetBinWidth(1);
   s.Form("Counts per %-.3g degrees",binsize);
   axis=hx->GetYaxis();
   if (axis) axis->SetTitle(s);
  }
 
  if (name=="hOnE" || name=="hOffE" || name=="hOnSigE")
  {
   binsize=hx->GetBinWidth(1);
   s.Form("Counts per %-.3g GeV",binsize);
   axis=hx->GetYaxis();
   if (axis) axis->SetTitle(s);
  }
 }
 
 // Determination of the on-source and off-source event rates
 Float_t nOn=non;
 Float_t nOff=noff;
 Float_t nsigOn=nsig;
 Float_t nbkgOn=nOn-nsigOn;
 Float_t Ton=DtwinOn*fTfact*float(fNgrbs);                // Total on-source exposure time in seconds
 Float_t Toff=DtwinOff*fTfact*float(fNgrbs)*float(fNbkg); // Total off-source exposure time in seconds
 Float_t rateOn=nOn/(DtwinOn*fTfact);
 Float_t rateOff=nOff/(DtwinOff*fTfact);
 
 // (Average) values per patch
 Float_t TwinOn=DtwinOn*fTfact;
 Float_t TwinOff=DtwinOff*fTfact;
 Float_t AvSolidangleOn=0;
 Float_t AvSolidangleOff=0;
 Float_t AvNon=0;
 Float_t AvNoff=0;
 Float_t AvRon=0;
 Float_t AvRoff=0;
 Float_t AvEon=0;
 Float_t AvEoff=0;
 Float_t AvNsigOn=0;
 Float_t AvNbkgOn=0;
 Float_t AvRsigOn=0;
 Float_t AvRbkgOn=0;
 Float_t AvEsigOn=0;
 Float_t AvEbkgOn=0;
 Float_t scale=fNgrbs;
 if (scale)
 {
  AvSolidangleOn=fSolidangleOn/scale;
  AvNon=nOn/scale;
  AvRon=nOn/Ton;
  AvEon=fEnergyOn/scale;
  AvNsigOn=nsigOn/scale;
  AvNbkgOn=nbkgOn/scale;
  AvRsigOn=nsigOn/Ton;
  AvRbkgOn=nbkgOn/Ton;
  AvEsigOn=fEnergySig/scale;
  AvEbkgOn=fEnergyBkg/scale;
 }
 scale=fNgrbs*fNbkg;
 if (scale)
 {
  AvSolidangleOff=fSolidangleOff/scale;
  AvNoff=nOff/scale;
  AvRoff=nOff/Toff;
  AvEoff=fEnergyOff/scale;
 }
 
 // Statistics of the stacked event samples
 printf("\n *%-s::MakeBurstDataStats* Statistics of the stacked observed event samples. \n",ClassName());
 printf(" Integrated on-source  exposure time of the %-i stacked time windows : %-g %-s \n",fNgrbs,Ton/fTfact,tu.Data());
 printf(" Integrated off-source exposure time of the %-i*%-i stacked time windows : %-g %-s \n",fNgrbs,fNbkg,Toff/fTfact,tu.Data());
 printf(" Total accumulated on-source  solid angle : %-g sr in %-i stacked patches --> Average per patch : %-g sr \n",fSolidangleOn,fNgrbs,AvSolidangleOn); 
 printf(" Total accumulated off-source solid angle : %-g sr in %-i*%-i stacked patches --> Average per patch : %-g sr \n",fSolidangleOff,fNgrbs,fNbkg,AvSolidangleOff);
 if (fSensarea>0) printf(" Area covered c.q. overlooked by the detector sensors : %-g m^2. \n",fSensarea);
 fSensarea*=1e4; // Convert to cm^2
 
 printf(" *On source*  Total number of recorded on-source events : %-g --> Average per patch : %-g events. \n",nOn,AvNon);
 printf("              --- Average values per on-source patch --- \n");
 printf("              Steady event rate during the time window : %-g Hz",AvRon);
 if (AvSolidangleOn) printf(" --> %-g Hz sr^-1",AvRon/AvSolidangleOn);
 printf("\n");
 if (fSensarea>0)
 {
  printf("              Particle fluence : %-g cm^-2",AvNon/fSensarea);
  if (AvSolidangleOn) printf(" --> %-g cm^-2 sr^-1",AvNon/(fSensarea*AvSolidangleOn));
  printf("\n");
  printf("              Particle flux : %-g cm^-2 s^-1",AvRon/fSensarea);
  if (AvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",AvRon/(fSensarea*AvSolidangleOn));
  printf("\n");
 }
 printf("              Cumulated energy : %-g GeV",AvEon);
 if (AvSolidangleOn) printf(" --> %-g GeV sr^-1",AvEon/AvSolidangleOn);
 printf("\n");
 printf("              Power : %-g GeV/s",AvEon/TwinOn);
 if (AvSolidangleOn) printf(" --> %-g GeV s^-1 sr^-1",AvEon/(TwinOn*AvSolidangleOn));
 printf("\n");
 if (fSensarea>0)
 {
  printf("              Energy fluence : %-g GeV cm^-2",AvEon/fSensarea);
  if (AvSolidangleOn) printf(" --> %-g GeV cm^-2 sr^-1",AvEon/(fSensarea*AvSolidangleOn));
  printf("\n");
  printf("              Energy flux : %-g GeV cm^-2 s^-1",AvEon/(fSensarea*TwinOn));
  if (AvSolidangleOn) printf(" --> Intensity : %-g GeV cm^-2 s^-1 sr^-1",AvEon/(fSensarea*TwinOn*AvSolidangleOn));
  printf("\n");
 }
 
 if (fNbkg)
 {
  printf(" *Off source* Total number of recorded off-source (background) events : %-g --> Average per patch : %-g events. \n",nOff,AvNoff);
  printf("              --- Average values per off-source patch --- \n");
  printf("              Steady event rate during the time window : %-g Hz",AvRoff);
  if (AvSolidangleOff) printf(" --> %-g Hz sr^-1",AvRoff/AvSolidangleOff);
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Particle fluence : %-g cm^-2",AvNoff/fSensarea);
   if (AvSolidangleOff) printf(" --> %-g cm^-2 sr^-1",AvNoff/(fSensarea*AvSolidangleOff));
   printf("\n");
   printf("              Particle flux : %-g cm^-2 s^-1",AvRoff/fSensarea);
   if (AvSolidangleOff) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",AvRoff/(fSensarea*AvSolidangleOff));
   printf("\n");
  }
  printf("              Cumulated energy : %-g GeV",AvEoff);
  if (AvSolidangleOff) printf(" --> %-g GeV sr^-1",AvEoff/AvSolidangleOff);
  printf("\n");
  printf("              Power : %-g GeV/s",AvEoff/TwinOff);
  if (AvSolidangleOff) printf(" --> %-g GeV s^-1 sr^-1",AvEoff/(TwinOn*AvSolidangleOff));
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Energy fluence : %-g GeV cm^-2",AvEoff/fSensarea);
   if (AvSolidangleOff) printf(" --> %-g GeV cm^-2 sr^-1",AvEoff/(fSensarea*AvSolidangleOff));
   printf("\n");
   printf("              Energy flux : %-g GeV cm^-2 s^-1",AvEoff/(fSensarea*TwinOff));
   if (AvSolidangleOff) printf(" --> Intensity : %-g GeV cm^-2 s^-1 sr^-1",AvEoff/(fSensarea*TwinOff*AvSolidangleOff));
   printf("\n");
  }
 }
 
 // On-source signal and background info is only available for simulated data
 if (!mode)
 {
  printf(" -(Unknown)-  Total number of injected on-source signal events : %-i \n",nmugrb);
  printf("              Total number of recorded on-source signal events : %-g",nsigOn);
  if (fNgrbs) printf(" --> Average per patch : %-g events.",nsigOn/float(fNgrbs));
  printf("\n");
  printf("              Total number of recorded on-source bkg    events : %-g",nbkgOn);
  if (fNgrbs) printf(" --> Average per patch : %-g events.",nbkgOn/float(fNgrbs));
  printf("\n");
 
  printf("              --- Average signal values per on-source patch --- \n");
  printf("              Steady event rate during the time window : %-g Hz",AvRsigOn);
  if (AvSolidangleOn) printf(" --> %-g Hz sr^-1",AvRsigOn/AvSolidangleOn);
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Particle fluence : %-g cm^-2",AvNsigOn/fSensarea);
   if (AvSolidangleOn) printf(" --> %-g cm^-2 sr^-1",AvNsigOn/(fSensarea*AvSolidangleOn));
   printf("\n");
   printf("              Particle flux : %-g cm^-2 s^-1",AvRsigOn/fSensarea);
   if (AvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",AvRsigOn/(fSensarea*AvSolidangleOn));
   printf("\n");
  }
  printf("              Cumulated energy : %-g GeV",AvEsigOn);
  if (AvSolidangleOn) printf(" --> %-g GeV sr^-1",AvEsigOn/AvSolidangleOn);
  printf("\n");
  printf("              Power : %-g GeV/s",AvEsigOn/TwinOn);
  if (AvSolidangleOn) printf(" --> %-g GeV s^-1 sr^-1",AvEsigOn/(TwinOn*AvSolidangleOn));
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Energy fluence : %-g GeV cm^-2",AvEsigOn/fSensarea);
   if (AvSolidangleOn) printf(" --> %-g GeV cm^-2 sr^-1",AvEsigOn/(fSensarea*AvSolidangleOn));
   printf("\n");
   printf("              Energy flux : %-g GeV cm^-2 s^-1",AvEsigOn/(fSensarea*TwinOn));
   if (AvSolidangleOn) printf(" --> Intensity : %-g GeV cm^-2 s^-1 sr^-1",AvEsigOn/(fSensarea*TwinOn*AvSolidangleOn));
   printf("\n");
  }
  printf("              --- Average background values per on-source patch --- \n");
  printf("              Steady event rate during the time window : %-g Hz",AvRbkgOn);
  if (AvSolidangleOn) printf(" --> %-g Hz sr^-1",AvRbkgOn/AvSolidangleOn);
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Particle fluence : %-g cm^-2",AvNbkgOn/fSensarea);
   if (AvSolidangleOn) printf(" --> %-g cm^-2 sr^-1",AvNbkgOn/(fSensarea*AvSolidangleOn));
   printf("\n");
   printf("              Particle flux : %-g cm^-2 s^-1",AvRbkgOn/fSensarea);
   if (AvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",AvRbkgOn/(fSensarea*AvSolidangleOn));
   printf("\n");
  }
  printf("              Cumulated energy : %-g GeV",AvEbkgOn);
  if (AvSolidangleOn) printf(" --> %-g GeV sr^-1",AvEbkgOn/AvSolidangleOn);
  printf("\n");
  printf("              Power : %-g GeV/s",AvEbkgOn/TwinOn);
  if (AvSolidangleOn) printf(" --> %-g GeV s^-1 sr^-1",AvEbkgOn/(TwinOn*AvSolidangleOn));
  printf("\n");
  if (fSensarea>0)
  {
   printf("              Energy fluence : %-g GeV cm^-2",AvEbkgOn/fSensarea);
   if (AvSolidangleOn) printf(" --> %-g GeV cm^-2 sr^-1",AvEbkgOn/(fSensarea*AvSolidangleOn));
   printf("\n");
   printf("              Energy flux : %-g GeV cm^-2 s^-1",AvEbkgOn/(fSensarea*TwinOn));
   if (AvSolidangleOn) printf(" --> Intensity : %-g GeV cm^-2 s^-1 sr^-1",AvEbkgOn/(fSensarea*TwinOn*AvSolidangleOn));
   printf("\n");
  }
 }
 printf("\n");
 
 // Update internal statistics
 fBurstParameters->AddNamedSlot("TminOn");
 fBurstParameters->SetSignal(TminOn,"TminOn");   
 fBurstParameters->AddNamedSlot("TmaxOn");
 fBurstParameters->SetSignal(TmaxOn,"TmaxOn");   
 fBurstParameters->AddNamedSlot("TminOff");
 fBurstParameters->SetSignal(TminOff,"TminOff");   
 fBurstParameters->AddNamedSlot("TmaxOff");
 fBurstParameters->SetSignal(TmaxOff,"TmaxOff");   
 fBurstParameters->AddNamedSlot("DtwinOn");
 fBurstParameters->SetSignal(DtwinOn,"DtwinOn");   
 fBurstParameters->AddNamedSlot("DtwinOff");
 fBurstParameters->SetSignal(DtwinOff,"DtwinOff");   
 fBurstParameters->AddNamedSlot("NbkgWinOn");
 fBurstParameters->SetSignal(NbkgWinOn,"NbkgWinOn");
 fBurstParameters->AddNamedSlot("NbkgWinOff");
 fBurstParameters->SetSignal(NbkgWinOff,"NbkgWinOff");
 fBurstParameters->AddNamedSlot("TtotOn");  // The on-source total exposure time in sec.
 fBurstParameters->SetSignal(Ton,"TtotOn");   
 fBurstParameters->AddNamedSlot("TtotOff"); // The off-source total exposure time ins sec.
 fBurstParameters->SetSignal(Toff,"TtotOff");   
 fBurstParameters->AddNamedSlot("AvSolidangleOn");  // The average on-source solid angle
 fBurstParameters->SetSignal(AvSolidangleOn,"AvSolidangleOn");   
 fBurstParameters->AddNamedSlot("AvSolidangleOff"); // The average off-source solid angle
 fBurstParameters->SetSignal(AvSolidangleOff,"AvSolidangleOff");   
 
 fBurstParameters->AddNamedSlot("rateOn");
 fBurstParameters->SetSignal(rateOn,"rateOn");
 fBurstParameters->AddNamedSlot("rateOff");
 fBurstParameters->SetSignal(rateOff,"rateOff");
 
 // Update old parameters
 fBurstParameters->SetSignal(TminOn,"Tmin");   
 fBurstParameters->SetSignal(TmaxOn,"Tmax");   
 fBurstParameters->SetSignal(DtwinOn,"Dtwin");   
 fBurstParameters->SetSignal(NbkgWinOn,"NbkgWin");
}

void NcAstrolab::MatchBurstData(NcDevice& matches,Int_t i1,Int_t i2,Int_t itype,Int_t j1,Int_t j2,Int_t jtype)
{
 
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 Float_t fTmin=fBurstParameters->GetSignal("Tmin");
 Float_t fTmax=fBurstParameters->GetSignal("Tmax");
 Float_t fDawin=fBurstParameters->GetSignal("Dawin");
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Float_t fMaxsigmatot=fBurstParameters->GetSignal("Maxsigmatot");
 Int_t fNbkg=TMath::Nint(fBurstParameters->GetSignal("Nbkg"));
 
 // Update internal statistics to account for objects introduced by hand
 Int_t fNgrbs=GetNsignals(0);
 Int_t fNevts=GetNsignals(1);
 fBurstParameters->AddNamedSlot("Ngrbs");
 fBurstParameters->AddNamedSlot("Nevts");
 fBurstParameters->SetSignal(fNgrbs,"Ngrbs");
 fBurstParameters->SetSignal(fNevts,"Nevts");
 
 // Initialize generic histograms for analysis
 InitBurstHistograms(1);
 
 TString tu="d";
 if (fTunits==1) tu="hrs";
 if (fTunits==2) tu="s";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 // Initialize the Device/Hit structure to contain the correlation info 
 matches.Reset(1);
 matches.SetHitCopy(1);
 
 TString name="Matches";
 TString title="Space and time matchings of NcAstrolab stored signals";
 matches.SetNameTitle(name,title);
 TString tux=tu;
 if (tu=="d") tux="days";
 if (tu=="hrs") tux="hours";
 if (tu=="s") tux="sec";
 TString namedamin="psimin in deg"; 
 TString namedtmin="dtmin in ";
 namedtmin+=tux;
 matches.AddNamedSlot(namedamin);
 matches.AddNamedSlot(namedtmin);
 matches.AddNamedSlot("ipsi");
 matches.AddNamedSlot("idt");
 
 NcSignal data;
 TString nameda="psi in deg"; 
 TString namedt="t2-t1 in ";
 namedt+=tux;
 data.AddNamedSlot("type1");
 data.AddNamedSlot("index1");
 data.AddNamedSlot("type2");
 data.AddNamedSlot("index2");
 data.AddNamedSlot(nameda);
 data.AddNamedSlot(namedt);
 
 if ((!itype || !jtype) && !fRefs)
 {
  printf(" *%-s::MatchBurstData* Error: itype=%-i jtype=%-i but no reference signals are present. \n",ClassName(),itype,jtype); 
  return;
 }
 
 if ((itype || jtype) && !fSigs)
 {
  printf(" *%-s::MatchBurstData* Error: itype=%-i jtype=%-i but no measurements are present. \n",ClassName(),itype,jtype); 
  return;
 }
 
 Int_t nrefs=0;
 if (fRefs) nrefs=fRefs->GetSize();
 Int_t nsigs=0;
 if (fSigs) nsigs=fSigs->GetSize();
 
 // Make input data consistent with conventions
 if (itype) itype=1;
 if (jtype) jtype=1;
 if (!itype)
 {
  if (i2<1 || i2>nrefs) i2=nrefs;
 }
 else
 {
  if (i2<1 || i2>nsigs) i2=nsigs;
 }
 if (!jtype)
 {
  if (j2<1 || j2>nrefs) j2=nrefs;
 }
 else
 {
  if (j2<1 || j2>nsigs) j2=nsigs;
 }
 
 if (i1<1 || j1<1 || i1>i2 || j1>j2)
 {
  printf(" *%-s::MatchBurstData* Inconsistent parameters: i1=%-i i2=%-i itype=%-i j1=%-i j2=%-i jtype=%-i. \n",ClassName(),i1,i2,itype,j1,j2,jtype); 
  return;
 }
 
 if (fDatype==1 && fMaxsigmatot<0)
 {
  printf(" *%-s::MatchBurstData* Incompatible parameter settings Datype=%-i Maxsigmatot=%-g \n",ClassName(),fDatype,fMaxsigmatot);
  printf(" === No matching analysis will be performed === \n");
 }
 
 // The number of actually stored items
 Int_t ni=GetNsignals(itype);
 Int_t nj=GetNsignals(jtype);
 
 // Additional text for histo titles to indicate scrambling of the corresponding data
 TString scrt=""; // Time scrambling
 TString scrp=""; // Position scrambling
 if (fTscmode>0) scrt="(scrambled)";
 if (fRscmode>0 || fTscmode==3) scrp="(scrambled)";
 
 // The auto binned event-burst time difference histo for the full selected sample
 Int_t nbins=10000;
 title.Form("Time difference %-s between events and bursts for the full selected dataset;Tevent-Tburst in %-s;Counts",scrt.Data(),tux.Data());
 TH1F* hTdiff=new TH1F("hTdiff",title,nbins,1,0);
 if (ni && nj) hTdiff->SetBuffer(ni*nj);
 
 // The auto binned event-burst angular difference histo for the full selected sample
 nbins=100;
 title.Form("Angular separation %-s between events and bursts for the full selected dataset;Opening angle in degrees;Counts",scrp.Data());
 TH1F* hAdiff=new TH1F("hAdiff",title,nbins,1,0);
 if (ni && nj) hAdiff->SetBuffer(ni*nj);
 
 // Recording of the cumulated on-source reconstructed event energy
 fBurstParameters->AddNamedSlot("EnergyOn");
 fBurstParameters->AddNamedSlot("EnergyOff");
 
 Double_t dang,dtime,diftheta;
 Int_t ix=0;
 Int_t jx=0;
 NcSignal* sxi=0;
 NcSignal* sxj=0;
 NcSignal* sxgrb=0;
 NcSignal* sxevt=0;
 Float_t sigmai=0;
 Float_t sigmaj=0;
 Float_t sigmagrb=0;
 Float_t sigmareco=0;
 Float_t sigmatot=0;
 Int_t id=0;
 Double_t dangmin=0;
 Double_t dtmin=0;
 Int_t idamin=0;
 Int_t idtmin=0;
 Bool_t first=kTRUE;
 Double_t dangmax=-1;
 Float_t Ereco=0;
 Float_t thlow=0;
 Float_t thup=0;
 Float_t thetagrb=0;
 Float_t solidangle=0;
 Int_t grbtype=0;
 Int_t k1=0;
 Int_t k2=0;
 Float_t zgrb=0;
 for (Int_t bkgpatch=0; bkgpatch<=fNbkg; bkgpatch++) // On-source and Off-source patches
 {
  if (bkgpatch && !fTscmode && !fRscmode) break; // No background data without time and/or position scrambling
 
  for (Int_t i=i1; i<=i2; i++)
  {
   sxi=GetSignal(i,itype);
   if (!sxi) continue;
 
   sigmai=sxi->GetSignal("csigma");
 
   if (itype && !fRecoangle) sigmai=fAngresfix;
 
   for (Int_t j=j1; j<=j2; j++)
   {
    // Skip matching a signal with itself
    if (itype==jtype && i==j) continue;
 
    sxj=GetSignal(j,jtype);
    if (!sxj) continue;
 
    sigmaj=sxj->GetSignal("csigma");
 
    if (jtype && !fRecoangle) sigmaj=fAngresfix;
 
    if (itype==jtype) // Self correlations
    {
     sigmagrb=sigmai;
     sxgrb=sxi;
     sigmareco=sigmaj;
     sxevt=sxj;
    }
    else // Correlations between sources and measurements
    {
     if (itype)
     {
      sigmareco=sigmai;
      sxevt=sxi;
      sigmagrb=sigmaj;
      sxgrb=sxj;
     }
     else
     {
      sigmagrb=sigmai;
      sxgrb=sxi;
      sigmareco=sigmaj;
      sxevt=sxj;
     }
    }
 
    sigmatot=-1;
    if (fSumsigmas==-1) sigmatot=sigmareco;
    if (fSumsigmas==0) sigmatot=sigmagrb;
    if (fSumsigmas==1) sigmatot=sigmagrb+sigmareco;
    if (fSumsigmas==2) sigmatot=sqrt(sigmagrb*sigmagrb+sigmareco*sigmareco);
 
    dangmax=-1;
    if (!fDatype) dangmax=fabs(fDawin);
    if (fDatype==1)
    {
     dangmax=0;
     if (fMaxsigmatot>0) dangmax=fabs(fDawin*fMaxsigmatot);
    }
    if (fDatype==2)
    {
     if (sigmatot>=0) dangmax=fabs(fDawin*sigmatot);
    }
 
    // Flag incompatible input for sigma summation
    if (fDatype==1 && fMaxsigmatot<0) dangmax=-1;
 
    ix=i;
    if (itype) ix=-i;
    jx=j;
    if (jtype) jx=-j;
 
    if (tu!="hrs")
    {
     dang=GetSeparation(ix,jx,"deg",dtime,tu,1,bkgpatch,&diftheta);
    }
    else
    {
     dang=GetSeparation(ix,jx,"deg",dtime,"s",1,bkgpatch,&diftheta);
     dtime=dtime/3600.;
    }
    
    if (!bkgpatch) // On-source data
    {
     // Fill the time difference histogram for full selected dataset
     if (hTdiff) hTdiff->Fill(dtime);
 
     // Fill the angular difference histogram for full selected dataset
     if (hAdiff) hAdiff->Fill(dang);
 
     // Initialize the On-source total solid angle for this source
     if (dangmax>=0 && !(sxgrb->GetSlotIndex("OmegaOn")))
     {
      sxgrb->AddNamedSlot("OmegaOn");
      if (fDawin<0) // Local zenith band
      {
       thlow=thetagrb-0.5*dangmax;
       thup=thetagrb+0.5*dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      else // Circle around GRB position
      {
       thlow=0;
       thup=dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      sxgrb->SetSignal(solidangle,"OmegaOn");
     }
    }
    else // Off-source c.q. background data 
    {
     // Initialize the Off-source total solid angle for this source
     if (dangmax>=0 && !(sxgrb->GetSlotIndex("OmegaOff")))
     {
      sxgrb->AddNamedSlot("OmegaOff");
      if (fDawin<0) // Local zenith band
      {
       thlow=thetagrb-0.5*dangmax;
       thup=thetagrb+0.5*dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      else // Circle around GRB position
      {
       thlow=0;
       thup=dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      sxgrb->SetSignal(solidangle,"OmegaOff");
     }
    }
 
    if (fDatype>=0)
    {
     if (fDawin<0) // Declination band
     {
      if (diftheta<thlow || diftheta>thup) continue;
     }
     else // Circle around the GRB
     {
      if (fabs(dang)>dangmax) continue;
     }
    }
 
    if (fTmax>fTmin && (dtime<fTmin || dtime>fTmax)) continue;
 
    if (!bkgpatch) // On-source data
    {
     // Tag this source of having an on-source matching event
     if (!(sxgrb->GetSlotIndex("HasMatchOn")))
     {
      sxgrb->AddNamedSlot("HasMatchOn");
      sxgrb->SetSignal(1,"HasMatchOn");
     }
 
     data.Reset();
     name="Object1=";
     name+=sxi->GetName();
     title="Object2=";
     title+=sxj->GetName();
     id++;
     data.SetNameTitle(name,title);
     data.SetUniqueID(id);
     data.SetSignal(itype,"type1");
     data.SetSignal(i,"index1");
     data.SetSignal(jtype,"type2");
     data.SetSignal(j,"index2");
     data.SetSignal(dtime,namedt);
     data.SetSignal(dang,nameda);
     matches.AddHit(data);
 
     // Update the maximum encountered dynamic On-source solid angle for this source
     if (fDatype==2)
     {
      if (fDawin<0) // Local zenith band
      {
       thlow=thetagrb-0.5*dangmax;
       thup=thetagrb+0.5*dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      else // Circle around GRB position
      {
       thlow=0;
       thup=dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      if (solidangle>sxgrb->GetSignal("OmegaOn")) sxgrb->SetSignal(solidangle,"OmegaOn");
     }
    }
    else // Off-source c.q. background data
    {
     // Tag this source of having an off-source matching event
     if (!(sxgrb->GetSlotIndex("HasMatchOff")))
     {
      sxgrb->AddNamedSlot("HasMatchOff");
      sxgrb->SetSignal(1,"HasMatchOff");
     }
 
     // Update the maximum encountered dynamic Off-source solid angle for this source
     if (fDatype==2)
     {
      if (fDawin<0) // Local zenith band
      {
       thlow=thetagrb-0.5*dangmax;
       thup=thetagrb+0.5*dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      else // Circle around GRB position
      {
       thlow=0;
       thup=dangmax;
       solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
      }
      if (solidangle>sxgrb->GetSignal("OmegaOff")) sxgrb->SetSignal(solidangle,"OmegaOff");
     }
    }
 
    // Fill the histograms for the matching data
    if (!bkgpatch) // On-source data
    {
     Ereco=sxevt->GetSignal("E");
     zgrb=sxgrb->GetSignal("z");
     fBurstOnReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
     fBurstOnMatch.Enter(Ereco,dtime,dang,dtime/(zgrb+1.));
     fBurstParameters->AddSignal(Ereco,"EnergyOn");
 
     // Record the data for the minimal encountered opening angle
     if (first || fabs(dang)<dangmin)
     {
      dangmin=fabs(dang);
      idamin=id;
     }
 
     // Record the data for the minimal encountered time difference
     if (first || fabs(dtime)<fabs(dtmin))
     {
      dtmin=dtime;
      idtmin=id;
     }
    
     first=kFALSE;
    }
    else // Off-source c.q. backgound data
    {
     Ereco=sxevt->GetSignal("E");
     zgrb=sxgrb->GetSignal("z");
     fBurstOffReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
     fBurstOffMatch.Enter(Ereco,dtime,dang,dtime/(zgrb+1.));
     fBurstParameters->AddSignal(Ereco,"EnergyOff");
    }
   } // End of the j-loop
  } // End of the i-loop
 } // End of loop over the patches
 
 // Store the filled histograms in the storage container
 if (hTdiff->GetEntries()) fBurstHistos.Add(hTdiff);
 if (hAdiff->GetEntries()) fBurstHistos.Add(hAdiff);
 
 // Recording of the On-source and Off-source total stacked solid angles
 name="SolidangleOn";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(0,name);
 name="SolidangleOff";
 fBurstParameters->AddNamedSlot(name);
 fBurstParameters->SetSignal(0,name);
 if (itype==jtype) // Self correlations
 {
  grbtype=itype;
  k1=i1;
  k2=i2;
 }
 else // Correlations between sources and measurements
 {
  if (itype)
  {
   grbtype=jtype;
   k1=j1;
   k2=j2;
  }
  else
  {
   grbtype=itype;
   k1=i1;
   k2=i2;
  }
 }
 // Loop over all grbs in the selection
 for (Int_t k=k1; k<=k2; k++)
 {
  sxgrb=GetSignal(k,grbtype);
  if (!sxgrb) continue;
 
  solidangle=sxgrb->GetSignal("OmegaOn");
  fBurstParameters->AddSignal(solidangle,"SolidangleOn");
 
  solidangle=sxgrb->GetSignal("OmegaOff");
  fBurstParameters->AddSignal(solidangle*float(fNbkg),"SolidangleOff");
 }
 
 // Store the data for the minimal encountered opening angle and time difference
 matches.SetSignal(dangmin,namedamin);
 matches.SetSignal(dtmin,namedtmin);
 matches.SetSignal(idamin,"ipsi");
 matches.SetSignal(idtmin,"idt");
 
 // Determine and list the burst statistics
 MakeBurstDataStats(1);
}

void NcAstrolab::MatchBurstData(NcDevice& matches,TString name,Int_t itype,Int_t j1,Int_t j2,Int_t jtype)
{
 
 Int_t i=GetSignalIndex(name,itype);
 
 if (i==-1) // Add the info for the requested Solar system object if not already stored
 {
  SetSolarSystem(name,0,itype);
  i=GetSignalIndex(name,itype);
  if (i>0) fSolUpdate=1;
 }
 
 if (i<1)
 {
  printf(" *%-s::MatchBurstData* Object %-s not found for itype=%-i. \n",ClassName(),name.Data(),itype); 
 }
 else
 {
  MatchBurstData(matches,i,i,itype,j1,j2,jtype);
 }
 
 fSolUpdate=0;
}

void NcAstrolab::InitBurstHistograms(Int_t mode)
{
 
 // Retreive the needed parameters
 Float_t fT90min=fBurstParameters->GetSignal("T90min");
 Float_t fT90max=fBurstParameters->GetSignal("T90max");
 Float_t fESigmin=fBurstParameters->GetSignal("ESigmin");
 Float_t fESigmax=fBurstParameters->GetSignal("ESigmax");
 Float_t fEmin=fBurstParameters->GetSignal("Emin");
 Float_t fEmax=fBurstParameters->GetSignal("Emax");
 Float_t fAlphasig=fBurstParameters->GetSignal("Alphasig");
 Float_t fAlphabkg=fBurstParameters->GetSignal("Alphabkg");
 Float_t fAvgrbz=fBurstParameters->GetSignal("Avgrbz");
 Float_t fAvgrbt90=fBurstParameters->GetSignal("Avgrbt90");
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 TString title;
 TString s;
 
 // Initialize the On-source and Off-source data samples
 fBurstOnReco.Reset();
 fBurstOnMatch.Reset();
 fBurstSigReco.Reset();
 fBurstSignal.Reset();
 fBurstOffReco.Reset();
 fBurstOffMatch.Reset();
 fBurstOnReco.SetNameTitle("BurstOnReco","On-source reco data");
 fBurstOnReco.SetStoreMode();
 fBurstOnReco.SetNames("zburst","sigmaburst","sigmareco","sigmacomb");
 fBurstOnMatch.SetNameTitle("BurstOnMatch","On-source matching data");
 fBurstOnMatch.SetStoreMode();
 fBurstOnMatch.SetNames("E","dtime","dang","dtimez");
 fBurstSigReco.SetNameTitle("BurstSigReco","Simulated signal reco data");
 fBurstSigReco.SetStoreMode();
 fBurstSigReco.SetNames("zburst","sigmaburst","sigmareco","sigmacomb");
 fBurstSignal.SetNameTitle("BurstSignal","Simulated signal events");
 fBurstSignal.SetStoreMode();
 fBurstSignal.SetNames("E","dtime","dang","dtimez");
 fBurstOffReco.SetNameTitle("BurstOffReco","Off-source reco data");
 fBurstOffReco.SetStoreMode();
 fBurstOffReco.SetNames("zburst","sigmaburst","sigmareco","sigmacomb");
 fBurstOffMatch.SetNameTitle("BurstOffMatch","Off-source matching data");
 fBurstOffMatch.SetStoreMode();
 fBurstOffMatch.SetNames("E","dtime","dang","dtimez");
 
 // Set default simulation signal and background energy spectra if needed
 if (!mode)
 {
  TH1* edist=0;
  edist=(TH1*)fBurstHistos.FindObject("hSigEpdf");
  if (!edist) MakeBurstEnergydist(2,fAlphasig,fESigmin,fESigmax,10000);
  edist=(TH1*)fBurstHistos.FindObject("hBkgEpdf");
  if (!edist) MakeBurstEnergydist(1,fAlphabkg,fEmin,fEmax,10000);
 }

 // Some statistics from the loaded data //
 
 Int_t fNgrbs=GetNsignals(0);
 Int_t fNevts=GetNsignals(1);
 
 Float_t xmin=0;
 Float_t xmax=0;
 Float_t range=0;
 Int_t nbins=100;
 Float_t binsize=0;
 Int_t srcbufsize=10000;
 if (fNgrbs && fNgrbs<srcbufsize) srcbufsize=fNgrbs;
 Int_t evtbufsize=10000;
 if (fNevts && fNevts<evtbufsize) evtbufsize=fNevts;
 
 // Creation of the burst redshift histo
 title.Form("Redshifts for the selected source sample;Redshift;Counts");
 TH1F* hSourceZ=new TH1F("hSourceZ",title,nbins,1,0);
 hSourceZ->SetBuffer(srcbufsize);
 
 // Creation of the corresponding physical distance histo
 nbins=100;
 title.Form("Distances for the selected source sample derived from the redshifts;Physical distance in Mpc;Counts");
 TH1F* hSourceD=new TH1F("hSourceD",title,nbins,xmin,xmax);
 hSourceD->SetBuffer(srcbufsize);
 
 // Creation of the burst t90 duration histo
 xmin=-5;
 if (fabs(fT90min)>0) xmin=log10(fabs(fT90min));
 xmax=5;
 if (fT90max>0) xmax=log10(fT90max);
 range=xmax-xmin;
 binsize=0.2; // Bins of 0.2
 nbins=TMath::Nint(range/binsize);
 if (nbins<1)
 {
  xmin=xmin-1.;
  xmax=xmax+1.;
  nbins=10;
 }
 title.Form("Burst durations for the selected source sample;Burst duration ^{10}log(T90) in sec.;Counts");
 TH1F* hBurstT90=new TH1F("hBurstT90",title,nbins,xmin,xmax);
 
 // Creation of the full selected sample burst position uncertainty histo with automatic binning
 nbins=100;
 title.Form("Position uncertainties for the selected source sample;Position angular uncertainty (sigma in degrees);Counts");
 TH1F* hSigmaSource=new TH1F("hSigmaSource",title,nbins,1,0);
 hSigmaSource->SetBuffer(srcbufsize);
 
 // Creation of the real event reconstructed energy histo with automatic binning
 TH1F* hEreco=0;
 nbins=1000;
 if (mode==1)
 {
  title.Form("Reconstructed energy for the full selected real event sample;Reconstructed event energy in GeV;Counts");
  hEreco=new TH1F("hEreco",title,nbins,1,0);
  hEreco->SetBuffer(evtbufsize);
 }
 
 // Creation of the injected source signal event energy histo with automatic binning
 TH1F* hSigE=0;
 TH1F* hSigEzcor=0;
 nbins=1000;
 if (mode==0)
 {
  title.Form("Injected signal energy at the source;Event energy in GeV;Counts");
  hSigE=new TH1F("hSigE",title,nbins,1,0);
  fBurstHistos.Add(hSigE);
  title.Form("(Redshift corrected) injected signal energy arriving at Earth;Event energy in GeV;Counts");
  hSigEzcor=new TH1F("hSigEzcor",title,nbins,1,0);
  fBurstHistos.Add(hSigEzcor);
 }
 
 // Creation of the full selected sample event reconstruction uncertainty histo with automatic binning
 TH1F* hSigmaReco=0;
 nbins=100;
 title.Form("Event reconstruction uncertainties for the full selected sample;Event angular reconstruction uncertainty (sigma in degrees);Counts");
 hSigmaReco=new TH1F("hSigmaReco",title,nbins,1,0);
 hSigmaReco->SetBuffer(evtbufsize);
 
 // Fill the generic source c.q. burst histograms
 NcSignal* sx=0;
 Float_t zgrb=0;
 Double_t dgrb=0;
 Float_t t90grb=0;
 Float_t sigmagrb=0;
 NcSample zsample;
 zsample.SetStoreMode();
 NcSample t90sample;
 t90sample.SetStoreMode();
 NcSample sigmasample;
 sigmasample.SetStoreMode();
 Int_t nsig=GetNsignals(0,1);
 for (Int_t i=1; i<=nsig; i++)
 {
  sx=GetSignal(i,0);
 
  if (!sx) continue;
 
  zgrb=sx->GetSignal("z");
  dgrb=GetPhysicalDistance(zgrb);
  t90grb=sx->GetSignal("T90");
  sigmagrb=sx->GetSignal("csigma");
 
  hSourceZ->Fill(zgrb);
  hSourceD->Fill(dgrb);
  if (t90grb>0) hBurstT90->Fill(log10(t90grb));
  hSigmaSource->Fill(sigmagrb);
 
  if (fAvgrbz<0) zsample.Enter(zgrb);
  if (fAvgrbt90<0) t90sample.Enter(t90grb);
  sigmasample.Enter(sigmagrb);
 }
 
 // Add the filled histograms to the storage container
 if (hSourceZ->GetEntries()) fBurstHistos.Add(hSourceZ);
 if (hSourceD->GetEntries()) fBurstHistos.Add(hSourceD);
 if (hBurstT90->GetEntries()) fBurstHistos.Add(hBurstT90);
 if (hSigmaSource->GetEntries()) fBurstHistos.Add(hSigmaSource);
 
 // Determine median redshift if requested
 if (fAvgrbz<0)
 {
  fAvgrbz=zsample.GetMedian(1);
  fAvgrbz*=-1.;
 }
 
 // Determine median T90 duration if requested
 if (fAvgrbt90<0)
 {
  fAvgrbt90=t90sample.GetMedian(1);
  fAvgrbt90*=-1.;
 }
 
 Float_t fAvgrbsigma=sigmasample.GetMedian(1);
 
 // Fill the generic event histograms
 Float_t sigmareco=0;
 Float_t Ereco=0;
 nsig=GetNsignals(1,1);
 for (Int_t i=1; i<=nsig; i++)
 {
  sx=GetSignal(i,1);
 
  if (!sx) continue;
 
  sigmareco=sx->GetSignal("csigma");
  Ereco=sx->GetSignal("E");
 
  if (hSigmaReco) hSigmaReco->Fill(sigmareco);
  if (hEreco) hEreco->Fill(Ereco);
 }
 
 // Add the filled histograms to the storage container
 if (hSigmaReco->GetEntries()) fBurstHistos.Add(hSigmaReco);
 if (hEreco)
 {
  if (hEreco->GetEntries()) fBurstHistos.Add(hEreco);
 }
 
 // Update internal statistics
 fBurstParameters->SetSignal(fAvgrbz,"Avgrbz");
 fBurstParameters->SetSignal(fAvgrbt90,"Avgrbt90");
 fBurstParameters->AddNamedSlot("Avgrbsigma");
 fBurstParameters->SetSignal(fAvgrbsigma,"Avgrbsigma");
}

void NcAstrolab::BurstCompensate(Int_t& nmugrb)
{
 
 // Retreive the needed parameters
 Float_t fGrbnu=fBurstParameters->GetSignal("Grbnu");
 Int_t fNgrbs=TMath::Nint(fBurstParameters->GetSignal("Ngrbs"));
 Int_t fInburst=TMath::Nint(fBurstParameters->GetSignal("Inburst"));
 Float_t fDtnu=fBurstParameters->GetSignal("Dtnu");
 Float_t fDtnus=fBurstParameters->GetSignal("Dtnus");
 Float_t fTimres=fBurstParameters->GetSignal("Timres");
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Float_t fDawin=fBurstParameters->GetSignal("Dawin");
 Float_t fTfact=fBurstParameters->GetSignal("Tfact");
 Int_t fEzcor=TMath::Nint(fBurstParameters->GetSignal("Ezcor"));
 Int_t fPDFsigE=TMath::Nint(fBurstParameters->GetSignal("PDFsigE"));
 Float_t fEmin=fBurstParameters->GetSignal("Emin");
 Float_t fEmax=fBurstParameters->GetSignal("Emax");
 Int_t fKinangle=TMath::Nint(fBurstParameters->GetSignal("Kinangle"));
 Float_t fAngresmin=fBurstParameters->GetSignal("Angresmin");
 Float_t fAngresmax=fBurstParameters->GetSignal("Angresmax");
 Float_t fAngresfix=fBurstParameters->GetSignal("Angresfix");
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 
 // Deactivate redshift correction for source signal events from archival observed data
 if (!fPDFsigE)
 {
  fEzcor=0;
  fBurstParameters->SetSignal(0,"Ezcor");
 } 
 
 Int_t nmu=int(fabs(fGrbnu)*float(fNgrbs));
 Int_t jgrb=0;
 NcSignal* sx=0;
 NcTimestamp* tx=0;
 Float_t t90grb=0;
 Float_t zgrb=0;
 Float_t sigmagrb=0;
 NcPosition rgrb;
 NcPosition rgrb2;
 Float_t dt=0;
 Double_t dgrb=0;
 Double_t thetagrb=0;
 Double_t phigrb=0;
 Float_t dang=0;
 Float_t dangmax=0;
 Float_t dangmaxOn=0;
 NcPosition rmu;
 Double_t E=0;
 Double_t sigmareco=0;
 Float_t sigmatot=0;
 Float_t OmegaOn=0; // The current on-source solid angle probed for a certain GRB
 Float_t thlow=0;
 Float_t thup=0;
 Float_t solidangle=0;
 Int_t fixedwinset=0; // Flag to indicate whether a fixed angular search window was set (1) or not (0) for this burst 
 
 TH1* hSigE=(TH1*)fBurstHistos.FindObject("hSigE");
 TH1* hSigEzcor=(TH1*)fBurstHistos.FindObject("hSigEzcor");
 
 while (nmugrb<nmu)
 {
  // Pick randomly one of the stored GRBs
  jgrb=int(fRan->Uniform(0.,float(fNgrbs)));
  if (jgrb==0) jgrb=1;
  sx=GetSignal(jgrb);
 
  if (!sx) continue;
 
  tx=sx->GetTimestamp();
  GetSignal(dgrb,thetagrb,"deg",phigrb,"deg","loc",tx,jgrb);
  rgrb.SetPosition(1,thetagrb,phigrb,"sph","deg");
  zgrb=sx->GetSignal("z");
  t90grb=sx->GetSignal("T90");
  sigmagrb=sx->GetSignal("csigma");
  fixedwinset=TMath::Nint(sx->GetSignal("fixedwinset"));
  dangmaxOn=sx->GetSignal("dangmaxOn");
  OmegaOn=sx->GetSignal("OmegaOn");
 
  dangmax=dangmaxOn;
 
  // Obtain actual GRB position
  rgrb2.Load(rgrb);
  SmearPosition(rgrb2,sigmagrb);
 
  nmugrb++;
 
  if (!fInburst) // Neutrino and gamma production decoupled
  {
   if (fDtnus<0) // Sigma in units of T90
   {
    dt=fRan->Gauss(fDtnu,fabs(fDtnus)*t90grb);
   }
   else // Sigma in seconds
   {
    dt=fRan->Gauss(fDtnu,fDtnus);
   }
   dt=dt*(zgrb+1.);
  }
  else // Coupled neutrino and gamma production
  {
   if (fDtnus<0) // Sigma in units of T90
   {
    dt=fRan->Gauss(fDtnu*t90grb,fabs(fDtnus)*t90grb);
   }
   else // Sigma in seconds
   {
    dt=fRan->Gauss(fDtnu*t90grb,fDtnus);
   }
  }
  if (fTimres>0) dt=fRan->Gauss(dt,fTimres);
 
  // Convert dt from seconds to the selected Tunits
  dt=dt/fTfact;
 
  // The direction of the GRB signal
  rmu.Load(rgrb2);
 
  // The energy of the GRB signal
  E=GetBurstSignalEnergy();
 
  if (hSigE) hSigE->Fill(E);
 
  // Reduce the energy due to the cosmological redshift effect
  if (fEzcor) E=E/(zgrb+1.);
 
  if (hSigEzcor) hSigEzcor->Fill(E);
 
  if (E<0 || E<fEmin || E>fEmax) continue;
 
  // Modification to account for the neutrino-lepton kinematic opening angle
  if (fKinangle>0)
  {
   Int_t mode=fKinangle-1;
   Double_t ang=GetNeutrinoAngle(E,"deg",mode);
   if (ang>0) ShiftPosition(rmu,ang);
  }
 
  // Smearing according to the reconstruction angular resolution
  sigmareco=GetBurstRecoAngres(E,E);
  if (sigmareco<0) sigmareco=fAngresfix;
 
  if (sigmareco<fAngresmin || sigmareco>fAngresmax) continue;
 
  SmearPosition(rmu,sigmareco);
 
  // Determine angular difference w.r.t. the presumed GRB position
  dang=rgrb.GetOpeningAngle(rmu,"deg");
 
  sigmatot=-1;
  if (fSumsigmas==-1) sigmatot=sigmareco;
  if (fSumsigmas==0) sigmatot=sigmagrb;
  if (fSumsigmas==1) sigmatot=sigmagrb+sigmareco;
  if (fSumsigmas==2) sigmatot=sqrt(sigmagrb*sigmagrb+sigmareco*sigmareco);
 
  // Determine the dynamic angular window including the track reco uncertainty
  if (!fixedwinset)
  {
   dangmax=-1;
   if (sigmatot>=0) dangmax=fabs(fDawin*sigmatot);
  }
 
  if (fDatype>=0 && dang>dangmax) continue;
 
  fBurstOnReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
  fBurstOnMatch.Enter(E,dt,dang,dt/(zgrb+1.));
  fBurstSigReco.Enter(zgrb,sigmagrb,sigmareco,sigmatot);
  fBurstSignal.Enter(E,dt,dang,dt/(zgrb+1.));
  fBurstParameters->AddSignal(E,"EnergyOn");
  fBurstParameters->AddSignal(E,"EnergySig");
 
  if (fixedwinset) continue;
  
  // Update the dynamic On-source maximum (solid) angle that is encountered for this burst
  if (fDawin<0) // Local zenith band
  {
   thlow=thetagrb-0.5*dangmax;
   thup=thetagrb+0.5*dangmax;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
  }
  else // Circle around GRB position
  {
   thlow=0;
   thup=dangmax;
   solidangle=GetSolidAngle(thlow,thup,"deg",0,360,"deg");
  }
  if (dangmax>dangmaxOn) sx->SetSignal(dangmax,"dangmaxOn");
  if (solidangle>OmegaOn) sx->SetSignal(solidangle,"OmegaOn");
 }
}

TH1* NcAstrolab::GetBurstBayesianSignalRate(Double_t p,Double_t& rlow,Double_t& rup,Int_t n)
{
 
 rlow=0;
 rup=0;
 
 // The number of on-source and off-source patches
 Int_t fNgrbs=GetNsignals(0);
 Int_t fNbkg=TMath::Nint(fBurstParameters->GetSignal("Nbkg"));
 
 // The recorded (stacked) on-source and off-source number of events
 Double_t Non=fBurstOnMatch.GetN();
 Double_t Noff=fBurstOffMatch.GetN();
 
 if (fNgrbs<=0 || fNbkg<=0 || Non<=0 || Noff<=0)
 {
  printf(" \n *%-s::GetBurstBayesianSignalRate* \n",ClassName());
  if (fNgrbs<=0 || Non<=0) printf(" === No on-source data available === \n");
  if (fNbkg<=0 || Noff<=0) printf(" === No off-source data available === \n");
  return 0;
 }
 
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 Float_t fTfact=fBurstParameters->GetSignal("Tfact");
 
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 // The (stacked) on-source and off-source solid angles that were probed
 Double_t fSolidangleOn=fBurstParameters->GetSignal("SolidangleOn");
 Double_t fSolidangleOff=fBurstParameters->GetSignal("SolidangleOff");
 Double_t fAvSolidangleOn=fBurstParameters->GetSignal("AvSolidangleOn");
 Double_t fAvSolidangleOff=fBurstParameters->GetSignal("AvSolidangleOff");
 Double_t Ra=-1;
 if (fAvSolidangleOff) Ra=fAvSolidangleOn/fAvSolidangleOff;
 
 // The integrated on-source and off-source exposure times in seconds
 Double_t Ton=fBurstParameters->GetSignal("TtotOn");
 Double_t Toff=fBurstParameters->GetSignal("TtotOff");
 
 // The Bayesian posterior background and signal rate PDFs
 TF1 fbkgrpdf=GetBackgroundRatePDF(Noff,Toff);
 TF1 fsigrpdf=GetSignalRatePDF(Non,Ton,Noff,Toff,Ra);
 
 Double_t rmode=fsigrpdf.GetMaximumX();
 Double_t bkgrmode=fbkgrpdf.GetMaximumX();
 
 // Determine the "p%" credible interval for the signal rate
 Float_t frac=0;
 frac=GetCredibleInterval(fsigrpdf,p,rlow,rup,n);
 
 // Provide the signal and background rate PDFs as histograms in the output file
 fbkgrpdf.SetRange(0,3.*Noff/Toff);
 fbkgrpdf.SetNpx(n);
 TH1* hBkgRatePDF=(TH1*)fbkgrpdf.GetHistogram()->Clone();
 hBkgRatePDF->SetName("hBkgRatePDF");
 fBurstHistos.Add(hBkgRatePDF);
 fsigrpdf.SetRange(0,3.*Non/Ton);
 fsigrpdf.SetNpx(n);
 TH1* hSigRatePDF=(TH1*)fsigrpdf.GetHistogram()->Clone();
 hSigRatePDF->SetName("hSigRatePDF");
 fBurstHistos.Add(hSigRatePDF);
 
 printf("\n *%-s::GetBurstBayesianSignalRate* Credible interval [rlow,rup] for p=%-g%% with a precision of 1/%-i \n",ClassName(),p,n);
 
 // Issue a warning in case variable angular cones based on actual track reco sigmas were used.
 // This can induce large variations in the on-source and off-source event counts
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 
 if (fRecoangle && fSumsigmas && fDatype==2)
 {
  printf(" === Warning: Variable angular cones based on actual track reconstruction sigmas were used. \n");
  printf("              Large variations between the on-source and off-source background counts may be present. \n");
 }
 
 printf(" The %-g%% credible interval from the Bayesian posterior signal pdf : [%-g,%-g] Hz \n",100.*frac,rlow,rup);
 printf(" Modes of the on-source posterior PDFs : Signal=%-g Hz Background=%-g Hz",rmode,bkgrmode);
 if (bkgrmode) printf(" Signal/Background=%-g",rmode/bkgrmode);
 printf("\n");
 cout << " The following signal and background rate PDF histograms have been generated :" << endl;
 cout << " ... " << hSigRatePDF->GetName() << " : " << hSigRatePDF->GetTitle() << endl;      
 cout << " ... " << hBkgRatePDF->GetName() << " : " << hBkgRatePDF->GetTitle() << endl;      
 
 // Provide statistics for the lower and upper signal rate boundaries and for the mode of the signal PDF as well 
 Float_t fSensarea=fBurstParameters->GetSignal("Sensarea");
 Float_t TwinOn=Ton/float(fNgrbs); // The average time window in seconds
 
 printf(" Integrated on-source  exposure time of the %-i stacked time windows : %-g %-s \n",fNgrbs,Ton/fTfact,tu.Data());
 printf(" Integrated off-source exposure time of the %-i*%-i stacked time windows : %-g %-s \n",fNgrbs,fNbkg,Toff/fTfact,tu.Data());
 printf(" Total accumulated on-source  solid angle : %-g sr in %-i stacked patches --> Average per patch : %-g sr \n",fSolidangleOn,fNgrbs,fAvSolidangleOn); 
 printf(" Total accumulated off-source solid angle : %-g sr in %-i*%-i stacked patches --> Average per patch : %-g sr \n",fSolidangleOff,fNgrbs,fNbkg,fAvSolidangleOff);
 if (fSensarea>0) printf(" Area covered c.q. overlooked by the detector sensors : %-g m^2. \n",fSensarea);
 fSensarea*=1e4; // Convert to cm^2
 
 printf(" Total number of recorded on-source  events : %-g --> Average per patch : %-g events. \n",Non,Non/float(fNgrbs));
 printf(" Total number of recorded off-source events : %-g --> Average per patch : %-g events. \n",Noff,Noff/float(fNgrbs*fNbkg));
 
 printf(" --- Average values per on-source patch based on the posterior PDFs --- \n");
 
 printf(" *Lower bound* Steady signal event rate during the time window : %-g Hz",rlow);
 if (fAvSolidangleOn) printf(" --> %-g Hz sr^-1",rlow/fAvSolidangleOn);
 printf("\n");
 printf("               Expected number of signal events : %-g",rlow*TwinOn);
 if (fAvSolidangleOn) printf(" --> %-g events/sr",rlow*TwinOn/fAvSolidangleOn);
 printf("\n");
 if (fSensarea>0)
 {
  printf("               Expected signal particle fluence : %-g cm^-2",rlow*TwinOn/fSensarea);
  if (fAvSolidangleOn) printf(" --> : %-g cm^-2 sr^-1",rlow*TwinOn/(fSensarea*fAvSolidangleOn));
  printf("\n");
  printf("               Expected signal particle flux : %-g cm^-2 s^-1",rlow/fSensarea);
  if (fAvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",rlow/(fSensarea*fAvSolidangleOn));
  printf("\n");
 }
 
 printf("    *Mode*     Steady signal event rate during the time window : %-g Hz",rmode);
 if (fAvSolidangleOn) printf(" --> %-g Hz sr^-1",rmode/fAvSolidangleOn);
 printf("\n");
 printf("               Expected number of signal events : %-g",rmode*TwinOn);
 if (fAvSolidangleOn) printf(" --> %-g events/sr",rmode*TwinOn/fAvSolidangleOn);
 printf("\n");
 if (fSensarea>0)
 {
  printf("               Expected signal particle fluence : %-g cm^-2",rmode*TwinOn/fSensarea);
  if (fAvSolidangleOn) printf(" --> : %-g cm^-2 sr^-1",rmode*TwinOn/(fSensarea*fAvSolidangleOn));
  printf("\n");
  printf("               Expected signal particle flux : %-g cm^-2 s^-1",rmode/fSensarea);
  if (fAvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",rmode/(fSensarea*fAvSolidangleOn));
  printf("\n");
 }
 
 printf(" *Upper bound* Steady signal event rate during the time window : %-g Hz",rup);
 if (fAvSolidangleOn) printf(" --> %-g Hz sr^-1",rup/fAvSolidangleOn);
 printf("\n");
 printf("               Expected number of signal events : %-g",rup*TwinOn);
 if (fAvSolidangleOn) printf(" --> %-g events/sr",rup*TwinOn/fAvSolidangleOn);
 printf("\n");
 if (fSensarea>0)
 {
  printf("               Expected signal particle fluence : %-g cm^-2",rup*TwinOn/fSensarea);
  if (fAvSolidangleOn) printf(" --> : %-g cm^-2 sr^-1",rup*TwinOn/(fSensarea*fAvSolidangleOn));
  printf("\n");
  printf("               Expected signal particle flux : %-g cm^-2 s^-1",rup/fSensarea);
  if (fAvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",rup/(fSensarea*fAvSolidangleOn));
  printf("\n");
 }
 
 printf(" *Background*  Steady background event rate during the time window : %-g Hz",bkgrmode);
 if (fAvSolidangleOn) printf(" --> %-g Hz sr^-1",bkgrmode/fAvSolidangleOn);
 printf("\n");
 printf("               Expected number of background events : %-g",bkgrmode*TwinOn);
 if (fAvSolidangleOn) printf(" --> %-g events/sr",bkgrmode*TwinOn/fAvSolidangleOn);
 printf("\n");
 if (fSensarea>0)
 {
  printf("               Expected background particle fluence : %-g cm^-2",bkgrmode*TwinOn/fSensarea);
  if (fAvSolidangleOn) printf(" --> : %-g cm^-2 sr^-1",bkgrmode*TwinOn/(fSensarea*fAvSolidangleOn));
  printf("\n");
  printf("               Expected background particle flux : %-g cm^-2 s^-1",bkgrmode/fSensarea);
  if (fAvSolidangleOn) printf(" --> Intensity : %-g cm^-2 s^-1 sr^-1",bkgrmode/(fSensarea*fAvSolidangleOn));
  printf("\n");
 }
 
 return hSigRatePDF;
}

Double_t NcAstrolab::GetBurstLiMaSignificance() const
{
 
 Double_t sigma=0;
 
 // The recorded (stacked) "on source" and "off source" number of events
 Double_t Non=fBurstOnMatch.GetN();
 Double_t Noff=fBurstOffMatch.GetN();
 
 if (Non<=0 || Noff<=0)
 {
  printf(" \n *%-s::GetBurstLiMaSignificance* \n",ClassName());
  if (Non<=0) printf(" === No on source data available === \n");
  if (Noff<=0) printf(" === No off source data available === \n");
  return 0;
 }
 
 // The (stacked) "on source" and "off source" solid angles that were probed
 Double_t fAvSolidangleOn=fBurstParameters->GetSignal("AvSolidangleOn");
 Double_t fAvSolidangleOff=fBurstParameters->GetSignal("AvSolidangleOff");
 Double_t Ra=-1;
 if (fAvSolidangleOff) Ra=fAvSolidangleOn/fAvSolidangleOff;
 
 // The (stacked) "on source" and "off source" exposure times
 Double_t Ton=fBurstParameters->GetSignal("TtotOn");
 Double_t Toff=fBurstParameters->GetSignal("TtotOff");
 
 NcMath m;
 sigma=m.LiMaSignificance(Non,Ton,Noff,Toff,Ra);
 
 printf("\n *%-s::GetBurstLiMaSignificance* The Li-Ma signal significance is : %-g \n",ClassName(),sigma);
 
 // Issue a warning in case variable angular cones based on actual track reco sigmas were used.
 // This can induce large variations in the on-source and off-source event counts
 Int_t fDatype=TMath::Nint(fBurstParameters->GetSignal("Datype"));
 Int_t fRecoangle=TMath::Nint(fBurstParameters->GetSignal("Recoangle"));
 Int_t fSumsigmas=TMath::Nint(fBurstParameters->GetSignal("Sumsigmas"));
 
 if (fRecoangle && fSumsigmas && fDatype==2)
 {
  printf(" === Warning: Variable angular cones based on actual track reconstruction sigmas were used. \n");
  printf("              Large variations between the on-source and off-source background counts may be present. \n");
 }
 
 return sigma;
}

void NcAstrolab::GetBurstBayesianPsiStatistics(TString type,Double_t nr,Int_t ncut,Int_t ndt,Bool_t zcor,Int_t freq)
{
 
 NcMath math;
 
 TString text="none";
 if (type=="time") text="arrival time";
 if (type=="BBtime") text="Bayesian Block event rate";
 if (type=="BBrat") text="normalized On-source/Off-source Bayesian Block event rate ratio";
 if (type=="angle") text="opening angle";
 if (type=="cosa") text="cos(opening angle)";
 if (type=="dt") text="arrival time interval";
 
 if (zcor)
 {
  text.ReplaceAll("arrival time","redshift corrected arrival time");
  text.ReplaceAll("event rate","redshift corrected event rate");
 }
 
 cout << endl; 
 if (text=="none")
 {
  cout << " *" << ClassName() << "::GetBurstBayesianPsiStatistics* Unknown statistics type : " << type << endl;
  return;
 }
 else
 {
  cout << " *" << ClassName() << "::GetBurstBayesianPsiStatistics* Analysis of " << text << " statistics" << endl;
 }
 
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 TH1* tot=0;
 TH1* bkg=0;
 TH1* rat=0;
 
 Double_t psitot=-1, psibkg=-1, psirat=-1;
 Float_t psidif=0;
 Float_t psimintot=-1, psimaxtot=-1, psifractot=0;
 Float_t psiminbkg=-1, psimaxbkg=-1, psifracbkg=0;
 Float_t psiminrat=-1, psimaxrat=-1, psifracrat=0;
 Double_t nrxtot=-1, nrxbkg=-1, nrxrat=-1;
 Double_t pvaluetot=-1, pvaluebkg=-1, pvaluerat=-1;
 
 TH1F* hPsiOn=0;
 TH1F* hPsiOff=0;
 TH1F* hPsiRat=0;
 TH1F* rtot=0;
 TH1F* rbkg=0;
 TH1F* rrat=0;

 // Arrival time histo Bayesian statistics //
 if (type=="time")
 {
  if (!zcor) // Plain observed arrival times
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnt");
   bkg=(TH1*)fBurstHistos.FindObject("hOfft");
  }
  else // Redshift corrected arrival times
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnZt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffZt");
  }
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  if (tot) psitot=math.PsiValue(tot,0,0,freq);
  if (bkg) psibkg=math.PsiValue(bkg,0,0,freq);
  psidif=psitot-psibkg;
 
  // Extreme Psi values for a pure background hypothesis of the recorded arrival time entries
  if (tot)
  {
   psimintot=math.PsiExtreme(tot,0,0,-2);
   if (psitot<psimintot) psimintot=psitot;
   psimaxtot=math.PsiExtreme(tot,0,0,-1);
   if (psimaxtot>psimintot) psifractot=(psimaxtot-psitot)/(psimaxtot-psimintot);
  }
  if (bkg)
  {
   psiminbkg=math.PsiExtreme(bkg,0,0,-2); 
   if (psibkg<psiminbkg) psiminbkg=psibkg;
   psimaxbkg=math.PsiExtreme(bkg,0,0,-1);
   if (psimaxbkg>psiminbkg) psifracbkg=(psimaxbkg-psibkg)/(psimaxbkg-psiminbkg);
  }
 
  // P-value determination
  if (nr>=0)
  {
   if (!zcor) // Plain observed arrival times
   {
    hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOnt");
    hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOfft");
   }
   else // Redshift corrected arrival times
   {
    hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOnZt");
    hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOffZt");
   }
 
   if (hPsiOn)
   {
    rtot=(TH1F*)hPsiOn->Clone();
    rtot->Reset();
   }
   else
   {
    if (tot)
    {
     if (!zcor) rtot=new TH1F("hPsiOnt","Psi distr. for bkg hypothesis of on-source arrival time data",100,psimintot-1.,psimaxtot+1.);
     if (zcor)  rtot=new TH1F("hPsiOnZt","Psi distr. for bkg hypothesis of redshift corrected on-source arrival time data",100,psimintot-1.,psimaxtot+1.);
    }
   }
 
   if (hPsiOff)
   {
    rbkg=(TH1F*)hPsiOff->Clone();
    rbkg->Reset();
   }
   else
   {
    if (bkg)
    {
     if (!zcor) rbkg=new TH1F("hPsiOfft","Psi distr. for bkg hypothesis of off-source arrival time data",100,psiminbkg-1.,psimaxbkg+1.);
     if (zcor)  rbkg=new TH1F("hPsiOffZt","Psi distr. for bkg hypothesis of redshift corrected off-source arrival time data",100,psiminbkg-1.,psimaxbkg+1.);
    }
   }
 
   if (tot)
   {
    pvaluetot=math.PsiPvalue(-1,nr,tot,0,0,freq,0,rtot,ncut,&nrxtot);
    fBurstHistos.Add(rtot);
   }
   if (bkg)
   {
    pvaluebkg=math.PsiPvalue(-1,nr,bkg,0,0,freq,0,rbkg,ncut,&nrxbkg);
    fBurstHistos.Add(rbkg);
   }
 
   cout << " The following randomised Psi histograms have been generated :" << endl;
   if (rtot) cout << " ... " << rtot->GetName() << " : " << rtot->GetTitle() << endl;      
   if (rbkg) cout << " ... " << rbkg->GetName() << " : " << rbkg->GetTitle() << endl;
  }
 }

 // Event rate histo Bayesian statistics   //
 if (type=="BBtime")
 {
  if (!zcor) // Plain observed arrival times
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnBBt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffBBt");
  }
  else // Redshift corrected arrival times
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnBBzt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffBBzt");
  }
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  // Temporarily offset the bin contents so that the lowest bin content is 1 for the psi analysis
  if (tot)
  {
   for (Int_t i=1; i<=tot->GetNbinsX(); i++)
   {
    tot->AddBinContent(i,1);
   }
  }
  
  if (bkg)
  {
   for (Int_t i=1; i<=bkg->GetNbinsX(); i++)
   {
    bkg->AddBinContent(i,1);
   }
  }
 
  if (tot) psitot=math.PsiValue(tot,0,0,freq);
  if (bkg) psibkg=math.PsiValue(bkg,0,0,freq);
  psidif=psitot-psibkg;
 
  // Extreme Psi values for a pure background hypothesis of the recorded arrival time entries
  if (tot)
  {
   psimintot=math.PsiExtreme(tot,0,0,-2);
   if (psitot<psimintot) psimintot=psitot;
   psimaxtot=math.PsiExtreme(tot,0,0,-1);
   if (psimaxtot>psimintot) psifractot=(psimaxtot-psitot)/(psimaxtot-psimintot);
  }
  if (bkg)
  {
   psiminbkg=math.PsiExtreme(bkg,0,0,-2); 
   if (psibkg<psiminbkg) psiminbkg=psibkg;
   psimaxbkg=math.PsiExtreme(bkg,0,0,-1);
   if (psimaxbkg>psiminbkg) psifracbkg=(psimaxbkg-psibkg)/(psimaxbkg-psiminbkg);
  }
 
  // P-value determination
  if (nr>=0)
  {
   if (!zcor) // Plain observed arrival times
   {
    hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOnBBt");
    hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOffBBt");
   }
   else // Redshift corrected arrival times
   {
    hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOnBBzt");
    hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOffBBzt");
   }
 
   if (hPsiOn)
   {
    rtot=(TH1F*)hPsiOn->Clone();
    rtot->Reset();
   }
   else
   {
    if (tot)
    {
     if (!zcor) rtot=new TH1F("hPsiOnBBt","Psi distr. for bkg hypothesis of on-source event rate Bayesian Block data",100,psimintot-1.,psimaxtot+1.);
     if (zcor)  rtot=new TH1F("hPsiOnBBzt","Psi distr. for bkg hypothesis of redshift corrected on-source event rate Bayesian Block data",100,psimintot-1.,psimaxtot+1.);
    }
   }
 
   if (hPsiOff)
   {
    rbkg=(TH1F*)hPsiOff->Clone();
    rbkg->Reset();
   }
   else
   {
    if (bkg)
    {
     if (!zcor) rbkg=new TH1F("hPsiOffBBt","Psi distr. for bkg hypothesis of off-source event rate Bayesian Block data",100,psiminbkg-1.,psimaxbkg+1.);
     if (zcor)  rbkg=new TH1F("hPsiOffBBzt","Psi distr. for bkg hypothesis of redshift corrected off-source event rate Bayesian Block data",100,psiminbkg-1.,psimaxbkg+1.);
    }
   }
 
   if (tot)
   {
    pvaluetot=math.PsiPvalue(-1,nr,tot,0,0,freq,0,rtot,ncut,&nrxtot);
    fBurstHistos.Add(rtot);
   }
   if (bkg)
   {
    pvaluebkg=math.PsiPvalue(-1,nr,bkg,0,0,freq,0,rbkg,ncut,&nrxbkg);
    fBurstHistos.Add(rbkg);
   }
 
   cout << " The following randomised Psi histograms have been generated :" << endl;
   if (rtot) cout << " ... " << rtot->GetName() << " : " << rtot->GetTitle() << endl;      
   if (rbkg) cout << " ... " << rbkg->GetName() << " : " << rbkg->GetTitle() << endl;
  }
 
  // Restore the original histogram data
  if (tot)
  {
   for (Int_t i=1; i<=tot->GetNbinsX(); i++)
   {
    tot->AddBinContent(i,-1);
   }
  }
  if (bkg)
  {
   for (Int_t i=1; i<=bkg->GetNbinsX(); i++)
   {
    bkg->AddBinContent(i,-1);
   }
  }
 }

 // On-source/Off-source event rate ratio histo Bayesian statistics //
 if (type=="BBrat")
 {
  if (!zcor) // Plain observed arrival times
  {
   rat=(TH1*)fBurstHistos.FindObject("hRatUBBt");
  }
  else // Redshift corrected arrival times
  {
   rat=(TH1*)fBurstHistos.FindObject("hRatUBBzt");
  }
 
  if (!rat)
  {
   printf(" === No data available === \n");
   return;
  }
 
  psirat=math.PsiValue(rat,0,0,freq);
  psidif=psitot-psibkg;
 
  // Extreme Psi values for a pure background hypothesis of the recorded arrival time entries
  psiminrat=math.PsiExtreme(rat,0,0,-2); 
  if (psirat<psiminrat) psiminrat=psirat;
  psimaxrat=math.PsiExtreme(rat,0,0,-1);
  if (psimaxrat>psiminrat) psifracrat=(psimaxrat-psirat)/(psimaxrat-psiminrat);
 
  // P-value determination
  if (nr>=0)
  {
   if (!zcor) // Plain observed arrival times
   {
    hPsiRat=(TH1F*)fBurstHistos.FindObject("hPsiRatUBBt");
   }
   else // Redshift corrected arrival times
   {
    hPsiRat=(TH1F*)fBurstHistos.FindObject("hPsiRatUBBzt");
   }
 
   if (hPsiRat)
   {
    rrat=(TH1F*)hPsiRat->Clone();
    rrat->Reset();
   }
   else
   {
    if (!zcor) rrat=new TH1F("hPsiRatUBBt","Psi distr. for bkg hypothesis of on/off source event rate Bayesian Block data",100,psiminrat-1.,psimaxrat+1.);
    if (zcor)  rrat=new TH1F("hPsiRatUBBzt","Psi distr. for bkg hypothesis of redshift corrected on/off source event rate Bayesian Block data",100,psiminrat-1.,psimaxrat+1.);
   }
 
   pvaluerat=math.PsiPvalue(-1,nr,rat,0,0,freq,0,rrat,ncut,&nrxrat);
   fBurstHistos.Add(rrat);
 
   cout << " The following randomised Psi histograms have been generated :" << endl;
   if (rrat) cout << " ... " << rrat->GetName() << " : " << rrat->GetTitle() << endl;
  }
 }
 
 // Opening angle histo Bayesian statistics //
 if (type=="angle")
 {
  tot=(TH1*)fBurstHistos.FindObject("hOna");
  bkg=(TH1*)fBurstHistos.FindObject("hOffa");
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  TF1 pdfa("pdfa","sin(x*acos(-1.)/180.)");
  if (tot) psitot=math.PsiValue(tot,0,&pdfa,freq);
  if (bkg) psibkg=math.PsiValue(bkg,0,&pdfa,freq);
  psidif=psitot-psibkg;
 
  // Extreme Psi values for a pure background hypothesis of the recorded opening angle entries
  if (tot)
  {
   psimintot=math.PsiExtreme(tot,0,&pdfa,-2);
   if (psitot<psimintot) psimintot=psitot;
   psimaxtot=math.PsiExtreme(tot,0,&pdfa,-1);
   if (psimaxtot>psimintot) psifractot=(psimaxtot-psitot)/(psimaxtot-psimintot);
  }
  if (bkg)
  {
   psiminbkg=math.PsiExtreme(bkg,0,&pdfa,-2);
   if (psibkg<psiminbkg) psiminbkg=psibkg;
   psimaxbkg=math.PsiExtreme(bkg,0,&pdfa,-1);
   if (psimaxbkg>psiminbkg) psifracbkg=(psimaxbkg-psibkg)/(psimaxbkg-psiminbkg);
  }
 
  // P-value determination
  if (nr>=0)
  {
   hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOna");
   hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOffa");
 
   if (hPsiOn)
   {
    rtot=(TH1F*)hPsiOn->Clone();
    rtot->Reset();
   }
   else
   {
    if (tot) rtot=new TH1F("hPsiOna","Psi distr. for bkg hypothesis of on-source opening angle data",100,psimintot-1.,psimaxtot+1.);
   }
 
   if (hPsiOff)
   {
    rbkg=(TH1F*)hPsiOff->Clone();
    rbkg->Reset();
   }
   else
   {
    if (bkg) rbkg=new TH1F("hPsiOffa","Psi distr. for bkg hypothesis of off-source opening angle data",100,psiminbkg-1.,psimaxbkg+1.);
   }
 
   if (tot)
   {
    pvaluetot=math.PsiPvalue(-1,nr,tot,0,&pdfa,freq,0,rtot,ncut,&nrxtot);
    fBurstHistos.Add(rtot);
   }
   if (bkg)
   {
    pvaluebkg=math.PsiPvalue(-1,nr,bkg,0,&pdfa,freq,0,rbkg,ncut,&nrxbkg);
    fBurstHistos.Add(rbkg);
   }
 
   cout << " The following randomised Psi histograms have been generated :" << endl;
   if (rtot) cout << " ... " << rtot->GetName() << " : " << rtot->GetTitle() << endl;      
   if (rbkg) cout << " ... " << rbkg->GetName() << " : " << rbkg->GetTitle() << endl;
  }      
 }

 // Cosine of opening angle histo Bayesian statistics //
 if (type=="cosa")
 {
  tot=(TH1*)fBurstHistos.FindObject("hOnCosa");
  bkg=(TH1*)fBurstHistos.FindObject("hOffCosa");
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  if (tot) psitot=math.PsiValue(tot,0,0,freq);
  if (bkg) psibkg=math.PsiValue(bkg,0,0,freq);
  psidif=psitot-psibkg;
 
  // Extreme Psi values for a pure background hypothesis of the recorded cos(opening angle) entries
  if (tot)
  {
   psimintot=math.PsiExtreme(tot,0,0,-2);
   if (psitot<psimintot) psimintot=psitot;
   psimaxtot=math.PsiExtreme(tot,0,0,-1);
   if (psimaxtot>psimintot) psifractot=(psimaxtot-psitot)/(psimaxtot-psimintot);
  }
  if (bkg)
  {
   psiminbkg=math.PsiExtreme(bkg,0,0,-2);
   if (psibkg<psiminbkg) psiminbkg=psibkg;
   psimaxbkg=math.PsiExtreme(bkg,0,0,-1);
   if (psimaxbkg>psiminbkg) psifracbkg=(psimaxbkg-psibkg)/(psimaxbkg-psiminbkg);
  }
 
  // P-value determination
  if (nr>=0)
  {
   hPsiOn=(TH1F*)fBurstHistos.FindObject("hPsiOnCosa");
   hPsiOff=(TH1F*)fBurstHistos.FindObject("hPsiOffCosa");
 
   if (hPsiOn)
   {
    rtot=(TH1F*)hPsiOn->Clone();
    rtot->Reset();
   }
   else
   {
    if (tot) rtot=new TH1F("hPsiOnCosa","Psi distr. for bkg hypothesis of on-source cos(opening angle) data",100,psimintot-1.,psimaxtot+1.);
   }
 
   if (hPsiOff)
   {
    rbkg=(TH1F*)hPsiOff->Clone();
    rbkg->Reset();
   }
   else
   {
    if (bkg) rbkg=new TH1F("hPsiOffCosa","Psi distr. for bkg hypothesis of off-source cos(opening angle) data",100,psiminbkg-1.,psimaxbkg+1.);
   }
 
    if (tot)
    {
     pvaluetot=math.PsiPvalue(-1,nr,tot,0,0,freq,0,rtot,ncut,&nrxtot);
     fBurstHistos.Add(rtot);
    }
    if (bkg)
    {
     pvaluebkg=math.PsiPvalue(-1,nr,bkg,0,0,freq,0,rbkg,ncut,&nrxbkg);
     fBurstHistos.Add(rbkg);
    }
 
    cout << " The following randomised Psi histograms have been generated :" << endl;
    if (rtot) cout << " ... " << rtot->GetName() << " : " << rtot->GetTitle() << endl;      
    if (rbkg) cout << " ... " << rbkg->GetName() << " : " << rbkg->GetTitle() << endl;
  }
 }

 // Arrival time interval Bayesian statistics //
 if (type=="dt")
 {
  TH1F hOndt;
  TH1F hOffdt;
  TF1 pdfdttot;
  TF1 pdfdtbkg;
 
  GetBurstDtDistributions(ndt,hOndt,pdfdttot,hOffdt,pdfdtbkg,zcor);
 
  Int_t ntot=hOndt.GetEntries();
  Int_t nbkg=hOffdt.GetEntries();
 
  if (!ntot) printf(" === No on source data available === \n");
  if (!nbkg) printf(" === No off source data available === \n");
 
  if (!ntot && !nbkg) return;
 
  if (ntot) psitot=math.PsiValue(&hOndt,0,&pdfdttot,freq);
  if (nbkg) psibkg=math.PsiValue(&hOffdt,0,&pdfdtbkg,freq);
  psidif=psitot-psibkg;
 
  if (ntot)
  {
   psimintot=math.PsiExtreme(&hOndt,0,&pdfdttot,-2);
   if (psitot<psimintot) psimintot=psitot;
   psimaxtot=math.PsiExtreme(&hOndt,0,&pdfdttot,-1);
   if (psimaxtot>psimintot) psifractot=(psimaxtot-psitot)/(psimaxtot-psimintot);
  }
  if (nbkg)
  {
   psiminbkg=math.PsiExtreme(&hOffdt,0,&pdfdtbkg,-2);
   if (psibkg<psiminbkg) psiminbkg=psibkg;
   psimaxbkg=math.PsiExtreme(&hOffdt,0,&pdfdtbkg,-1);
   if (psimaxbkg>psiminbkg) psifracbkg=(psimaxbkg-psibkg)/(psimaxbkg-psiminbkg);
  }
 
  // P-value determination
  if (nr>=0)
  {
   TString nametot;
   TString namebkg;
   if (!zcor)
   {
    nametot.Form("hPsiOndt%-i",ndt);
    namebkg.Form("hPsiOffdt%-i",ndt);
   }
   else
   {
    nametot.Form("hPsiOnZdt%-i",ndt);
    namebkg.Form("hPsiOffZdt%-i",ndt);
   }
 
   TH1F* hPsiOn=(TH1F*)fBurstHistos.FindObject(nametot);
   TH1F* hPsiOff=(TH1F*)fBurstHistos.FindObject(namebkg);
 
   TString title;
   if (hPsiOn)
   {
    rtot=(TH1F*)hPsiOn->Clone();
    rtot->Reset();
   }
   else
   {
    if (!zcor) title.Form("Psi distr. for bkg hypothesis of on-source dt data for n=%-i",ndt);
    if (zcor)  title.Form("Psi distr. for bkg hypothesis of redshift corrected on-source dt data for n=%-i",ndt);
    if (ntot) rtot=new TH1F(nametot,title,100,psimintot-1.,psimaxtot+1.);
   }
 
   if (hPsiOff)
   {
    rbkg=(TH1F*)hPsiOff->Clone();
    rbkg->Reset();
   }
   else
   {
    if (!zcor) title.Form("Psi distr. for bkg hypothesis of off-source dt data for n=%-i",ndt);
    if (zcor)  title.Form("Psi distr. for bkg hypothesis of redshift corrected off-source dt data for n=%-i",ndt);
    if (nbkg) rbkg=new TH1F(namebkg,title,100,psiminbkg-1.,psimaxbkg+1.);
   }
 
   if (ntot)
   {
    pvaluetot=math.PsiPvalue(-1,nr,&hOndt,0,&pdfdttot,freq,0,rtot,ncut,&nrxtot);
    fBurstHistos.Add(rtot);
   }
   if (nbkg)
   {
    pvaluebkg=math.PsiPvalue(-1,nr,&hOffdt,0,&pdfdtbkg,freq,0,rbkg,ncut,&nrxbkg);
    fBurstHistos.Add(rbkg);
   }
 
   cout << " The following randomised Psi histograms have been (re)generated :" << endl;
   if (rtot) cout << " ... " << rtot->GetName() << " : " << rtot->GetTitle() << endl;      
   if (rbkg) cout << " ... " << rbkg->GetName() << " : " << rbkg->GetTitle() << endl;
  }
 }
 
 // Listing of the statistics results
 cout << " *** Observed Psi values (in dB) for the hypothesis of no burst signal ***" << endl;
 if (psitot>=0) cout << " For the on-source  stacked patches : psi = " << psitot << endl;
 if (psibkg>=0) cout << " For the off-source stacked patches : psi = " << psibkg << endl;
 if (psitot>=0 && psibkg>=0) cout << " --> Difference between observed on-source and off-source psi values : " << psidif << endl;
 if (psirat>=0) cout << " For the on/off source event rate Bayesian Blocks : psi = " << psirat << endl;
 cout << " *** Extreme Psi values for the case of pure background ***" << endl;
 if (psimintot>=0) cout << " For on-source  psimin : " << psimintot << " psimax : " << psimaxtot;
 if (psifractot>0) printf(" (psimax-psi)/range : %-g",psifractot);
 if (psimintot>=0 || psifractot>0) printf("\n");
 if (psiminbkg>=0) cout << " For off-source psimin : " << psiminbkg << " psimax : " << psimaxbkg;
 if (psifracbkg>0) printf(" (psimax-psi)/range : %-g",psifracbkg);
 if (psiminbkg>=0 || psifracbkg>0) printf("\n");
 if (psiminrat>=0) cout << " For on/off source event rate Bayesian Blocks psimin : " << psiminrat << " psimax : " << psimaxrat;
 if (psifracrat>0) printf(" (psimax-psi)/range : %-g",psifracrat);
 if (psiminrat>=0 || psifracrat>0) printf("\n");
 
 if (nr>=0)
 {
  cout << " *** P-values of the observed on-source and off-source psi values ***" << endl;
  if (nrxtot>0) cout << " For the on-source  stacked patches : P-value = " << pvaluetot << " Used number of randomisations : " << nrxtot << endl;
  if (nrxbkg>0) cout << " For the off-source stacked patches : P-value = " << pvaluebkg << " Used number of randomisations : " << nrxbkg << endl;
  if (nrxrat>0) cout << " For the on/off source event rate Bayesian Blocks : P-value = " << pvaluerat << " Used number of randomisations : " << nrxrat << endl;
 }
}

void NcAstrolab::GetBurstChi2Statistics(TString type,Int_t ndt,Bool_t zcor)
{
 
 NcMath math;
 
 TString text="none";
 if (type=="time") text="arrival time";
 if (type=="BBtime") text="Bayesian Block event rate";
 if (type=="BBrat") text="normalized On-source/Off-source Bayesian Block event rate ratio";
 if (type=="angle") text="opening angle";
 if (type=="cosa") text="cos(opening angle)";
 if (type=="dt") text="arrival time interval";
 
 if (zcor)
 {
  text.ReplaceAll("arrival time","redshift corrected arrival time");
  text.ReplaceAll("event rate","redshift corrected event rate");
 }
 
 cout << endl; 
 if (text=="none")
 {
  cout << " *" << ClassName() << "::GetBurstChi2Statistics* Unknown statistics type : " << type << endl;
  return;
 }
 else
 {
  cout << " *" << ClassName() << "::GetBurstChi2Statistics* Analysis of " << text << " statistics" << endl;
 }
 
 TH1* tot=0;
 TH1* bkg=0;
 TH1* rat=0;
 
 Int_t ndftot=0;
 Int_t ndfbkg=0;
 Int_t ndfrat=0;
 Float_t chitot=0;
 Float_t chibkg=0;
 Float_t chirat=0;

 // Arrival time histo Chi-squared statistics //
 if (type=="time")
 {
  if (!zcor)
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnt");
   bkg=(TH1*)fBurstHistos.FindObject("hOfft");
  }
  else
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnZt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffZt");
  }
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  if (tot) chitot=math.Chi2Value(tot,0,0,&ndftot);
  if (bkg) chibkg=math.Chi2Value(bkg,0,0,&ndfbkg);
 }

 // Event rate histo Chi-squared statistics //
 if (type=="BBtime")
 {
  if (!zcor)
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnBBt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffBBt");
  }
  else
  {
   tot=(TH1*)fBurstHistos.FindObject("hOnBBzt");
   bkg=(TH1*)fBurstHistos.FindObject("hOffBBzt");
  }
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  if (tot) chitot=math.Chi2Value(tot,0,0,&ndftot);
  if (bkg) chibkg=math.Chi2Value(bkg,0,0,&ndfbkg);
 }

 // On-source/Off-source event rate ratio histo Chi-squared statistics //
 if (type=="BBrat")
 {
  if (!zcor)
  {
   rat=(TH1*)fBurstHistos.FindObject("hRatUBBt");
  }
  else
  {
   rat=(TH1*)fBurstHistos.FindObject("hRatUBBzt");
  }
 
  if (!rat)
  {
   printf(" === No data available === \n");
   return;
  }
 
  chirat=math.Chi2Value(rat,0,0,&ndfrat);
 }

 // Opening angle histo Chi-squared statistics //
 if (type=="angle")
 {
  tot=(TH1*)fBurstHistos.FindObject("hOna");
  bkg=(TH1*)fBurstHistos.FindObject("hOffa");
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  TF1 pdf("pdf","sin(x*acos(-1.)/180.)");
  if (tot) chitot=math.Chi2Value(tot,0,&pdf,&ndftot);
  if (bkg) chibkg=math.Chi2Value(bkg,0,&pdf,&ndfbkg);
 }

 // Cosine of opening angle histo Chi-squared statistics //
 if (type=="cosa")
 {
  tot=(TH1*)fBurstHistos.FindObject("hOnCosa");
  bkg=(TH1*)fBurstHistos.FindObject("hOffCosa");
 
  if (!tot) printf(" === No on source data available === \n");
  if (!bkg) printf(" === No off source data available === \n");
 
  if (!tot && !bkg) return;
 
  if (tot) chitot=math.Chi2Value(tot,0,0,&ndftot);
  if (bkg) chibkg=math.Chi2Value(bkg,0,0,&ndfbkg);
 }

 // Arrival time interval Chi-squared statistics //
 if (type=="dt")
 {
  TH1F hOndt;
  TH1F hOffdt;
  TF1 pdfdttot;
  TF1 pdfdtbkg;
 
  GetBurstDtDistributions(ndt,hOndt,pdfdttot,hOffdt,pdfdtbkg,zcor);
 
  Int_t ntot=hOndt.GetEntries();
  Int_t nbkg=hOffdt.GetEntries();
 
  if (!ntot) printf(" === No on source data available === \n");
  if (!nbkg) printf(" === No off source data available === \n");
 
  if (!ntot && !nbkg) return;
 
  if (ntot) chitot=math.Chi2Value(&hOndt,0,&pdfdttot,&ndftot);
  if (nbkg) chibkg=math.Chi2Value(&hOffdt,0,&pdfdtbkg,&ndfbkg);
 }
 
 // Listing of the statistics results
 Float_t chidif=chitot-chibkg;
 cout << " *** Observed Chi-squared values for the hypothesis of no burst signal ***" << endl;
 if (chitot>0) cout << " For the on-source  stacked patches : chi2 = " << chitot << " ndf = " << ndftot << endl;
 if (chibkg>0) cout << " For the off-source stacked patches : chi2 = " << chibkg << " ndf = " << ndfbkg << endl;
 if (chitot>0 && chibkg>0) cout << " --> Difference between observed on-source and off-source chi2 values : " << chidif << endl;
 if (chirat>0) cout << " For the on/off source event rate Bayesian Blocks : chi2 = " << chirat << " ndf = " << ndfrat << endl;
 
 Float_t ptot=-1;
 Float_t sigmatot=-1;
 Float_t pbkg=-1;
 Float_t sigmabkg=-1;
 Float_t prat=-1;
 Float_t sigmarat=-1;
 
 if (chitot)
 {
  ptot=math.Chi2Pvalue(chitot,ndftot);
  sigmatot=math.Chi2Pvalue(chitot,ndftot,0,1);
 }
 if (chibkg)
 {
  pbkg=math.Chi2Pvalue(chibkg,ndfbkg);
  sigmabkg=math.Chi2Pvalue(chibkg,ndfbkg,0,1);
 }
 if (chirat)
 {
  prat=math.Chi2Pvalue(chirat,ndfrat);
  sigmarat=math.Chi2Pvalue(chirat,ndfrat,0,1);
 }
 
 cout << " *** P-values of the observed on-source and off-source chi2 values ***" << endl;
 if (ptot>=0) cout << " For the on-source  stacked patches : P-value = " << ptot << " (" << sigmatot << " sigma)" << endl;
 if (pbkg>=0) cout << " For the off-source stacked patches : P-value = " << pbkg << " (" << sigmabkg << " sigma)" << endl;
 if (prat>=0) cout << " For the on/off source event rate Bayesian Blocks : P-value = " << prat << " (" << sigmarat << " sigma)" << endl;
}

void NcAstrolab::GetBurstDtDistributions(Int_t ndt,TH1F& hisdtOn,TF1& pdfdtOn,TH1F& hisdtOff,TF1& pdfdtOff,Bool_t zcor)
{
 
 
 hisdtOn.Reset();
 hisdtOff.Reset();
 
 Int_t fTunits=TMath::Nint(fBurstParameters->GetSignal("Tunits"));
 TString tu="days";
 if (fTunits==1) tu="hours";
 if (fTunits==2) tu="sec";
 if (fTunits==3) tu="ns";
 if (fTunits==4) tu="ps";
 
 Float_t fTfact=fBurstParameters->GetSignal("Tfact");
 
 TString nametot;
 TString namebkg;
 TString varname;
 
 // Create the automatically binned delta t histograms
 if (!zcor)
 {
  nametot.Form("hOndt%-i",ndt);
  namebkg.Form("hOffdt%-i",ndt);
  varname="dtime";
 }
 else
 {
  nametot.Form("hOnZdt%-i",ndt);
  namebkg.Form("hOffZdt%-i",ndt);
  varname="dtimez";
 }
 TH1F* hOndt=(TH1F*)fBurstHistos.FindObject(nametot);
 TH1F* hOffdt=(TH1F*)fBurstHistos.FindObject(namebkg);
 
 TString title;
 Double_t deltatbin=0;
 Int_t nOndt=0;
 Int_t nOffdt=0;
 
 if (!hOndt)
 {
  NcSample sOndt=fBurstOnMatch.GetDtSample(varname,ndt);
  nOndt=sOndt.GetN();
 
  if (nOndt)
  {
   hOndt=new TH1F(nametot,"histo",10000,1,0);
 
   hOndt->SetBuffer(nOndt);
 
   for (Int_t i=1; i<=nOndt; i++)
   {
    hOndt->Fill(sOndt.GetEntry(i,1));
   }
 
   hOndt->BufferEmpty(1);
 
   // Create title and labels for this delta t histograms
   deltatbin=hOndt->GetXaxis()->GetBinWidth(1);
   if (!zcor) title.Form("Time intervals between %-i consecutive events in the on-source time window;dt in %-s;Counts per %-.3g %-s",(ndt+1),tu.Data(),deltatbin,tu.Data());
   if (zcor)  title.Form("Time intervals between %-i consecutive events in the redshift corrected on-source time window;dt in %-s;Counts per %-.3g %-s",(ndt+1),tu.Data(),deltatbin,tu.Data());
   hOndt->SetTitle(title);
 
   fBurstHistos.Add(hOndt);
  }
 }
 
 if (!hOffdt)
 {
  NcSample sOffdt=fBurstOffMatch.GetDtSample(varname,ndt);
  nOffdt=sOffdt.GetN();
 
  if (nOffdt)
  {
   hOffdt=new TH1F(namebkg,"histo",10000,1,0);
 
   hOffdt->SetBuffer(nOffdt);
 
   for (Int_t i=1; i<=nOffdt; i++)
   {
    hOffdt->Fill(sOffdt.GetEntry(i,1));
   }
 
   hOffdt->BufferEmpty(1);
 
   // Create title and labels for this delta t histograms
   deltatbin=hOffdt->GetXaxis()->GetBinWidth(1);
   if (!zcor) title.Form("Time intervals between %-i consecutive events in the off-source time window;dt in %-s;Counts per %-.3g %-s",(ndt+1),tu.Data(),deltatbin,tu.Data());
   if (zcor)  title.Form("Time intervals between %-i consecutive events in the redshift corrected off-source time window;dt in %-s;Counts per %-.3g %-s",(ndt+1),tu.Data(),deltatbin,tu.Data());
   hOffdt->SetTitle(title);
 
   fBurstHistos.Add(hOffdt);
  }
 }
 
 if (hOndt || hOffdt) cout << " The following arrival time interval (dt) histograms have been generated :" << endl;
 if (hOndt) cout << " ... " << hOndt->GetName() << " : " << hOndt->GetTitle() << endl;      
 if (hOffdt) cout << " ... " << hOffdt->GetName() << " : " << hOffdt->GetTitle() << endl;
 
 if (hOndt) hisdtOn=*hOndt;
 if (hOffdt) hisdtOff=*hOffdt;
 
 // Creation of the Poisson based dt PDFs from the observed data for a background only hypothesis 
 
 Double_t rateOn=fBurstParameters->GetSignal("rateOn");
 Double_t rateOff=fBurstParameters->GetSignal("rateOff");
 
 // Convert the event rates into the correct units
 rateOn*=fTfact;
 rateOff*=fTfact;
 
 if (zcor) // Redshift corrected arrival times
 {
  Double_t nevt=fBurstOnMatch.GetN();
  Double_t tmin=fBurstOnMatch.GetMinimum(varname);
  Double_t tmax=fBurstOnMatch.GetMaximum(varname);
  Double_t twin=tmax-tmin;
  rateOn=0;
  if (twin) rateOn=nevt/twin;
  nevt=fBurstOffMatch.GetN();
  tmin=fBurstOffMatch.GetMinimum(varname);
  tmax=fBurstOffMatch.GetMaximum(varname);
  twin=tmax-tmin;
  rateOff=0;
  if (twin) rateOff=nevt/twin;
 }
 
 // Determine the corresponding dt PDFs based on Poisson statistics
 // Only the bkg dt PDF is used, since this may be obtained from off-source measurements.
 // Using the total dt PDF would artificially lower the sensitivity due to possible signal events.
 
 NcMath math;
 pdfdtOn=math.PoissonDtDist(rateOn,ndt);   // Poisson dt pdf for the observed on source event rate
 pdfdtOff=math.PoissonDtDist(rateOff,ndt); // Poisson dt pdf for the observed off source event rate
 
 if (!zcor)
 {
  nametot.Form("hpdfOndt%-i",ndt);
  namebkg.Form("hpdfOffdt%-i",ndt);
 }
 else
 {
  nametot.Form("hpdfOnZdt%-i",ndt);
  namebkg.Form("hpdfOffZdt%-i",ndt);
 }
 TH1* hpdfOndt=(TH1*)fBurstHistos.FindObject(nametot);
 TH1* hpdfOffdt=(TH1*)fBurstHistos.FindObject(namebkg);
 
 Double_t xmaxfdt=1;
 Double_t deltatmax=0;
 if (hOndt)
 {
  deltatmax=hOndt->GetXaxis()->GetXmax();
  xmaxfdt=deltatmax;
 }
 if (hOffdt)
 {
  deltatmax=hOffdt->GetXaxis()->GetXmax();
  if (deltatmax>xmaxfdt) xmaxfdt=deltatmax;
 }
 Int_t npx=10000;
 pdfdtOn.SetRange(0,xmaxfdt);
 pdfdtOn.SetNpx(npx);
 pdfdtOff.SetRange(0,xmaxfdt);
 pdfdtOff.SetNpx(npx);
 
 // Provide the dt PDFs as histograms in the output file
 if (!hpdfOndt && nOndt)
 {
  hpdfOndt=(TH1*)pdfdtOn.GetHistogram()->Clone();
  hpdfOndt->SetName(nametot.Data());
  title.Form("dt in %-s",tu.Data());
  hpdfOndt->GetXaxis()->SetTitle(title);
  fBurstHistos.Add(hpdfOndt);
 }
 
 if (!hpdfOffdt && nOffdt)
 {
  hpdfOffdt=(TH1*)pdfdtOff.GetHistogram()->Clone();
  hpdfOffdt->SetName(namebkg.Data());
  hpdfOffdt->GetXaxis()->SetTitle(title);
  fBurstHistos.Add(hpdfOffdt);
 }
 
 if (hpdfOndt || hpdfOffdt) cout << " The following arrival time interval (dt) PDFs have been generated :" << endl;
 if (hpdfOndt) cout << " ... " << hpdfOndt->GetName() << " : " << hpdfOndt->GetTitle() << endl;      
 if (hpdfOffdt) cout << " ... " << hpdfOffdt->GetName() << " : " << hpdfOffdt->GetTitle() << endl;
}

void NcAstrolab::ListBurstHistograms() const
{
 
 Int_t nh=fBurstHistos.GetEntries();
 cout << endl;
 cout << " =============== The following " << nh << " histograms have been generated ===============" << endl;
 for (Int_t ih=0; ih<nh; ih++)
 {
  TObject* hx=fBurstHistos.At(ih);
  if (!hx) continue;
  cout << " " << hx->GetName() << " : " << hx->GetTitle() << endl;
 }
 cout << " ===============================================================================" << endl;
}

void NcAstrolab::WriteBurstHistograms(TString filename)
{
 
 // The output file for the produced histograms
 TFile fout(filename.Data(),"RECREATE","NcAstrolab analysis results");
 
 // Write all the histos to the output file
 Int_t nh=fBurstHistos.GetEntries();
 for (Int_t ih=0; ih<nh; ih++)
 {
  TObject* hx=fBurstHistos.At(ih);
  if (!hx) continue;
  hx->Write();
 }
 
 fout.Write();
 
 cout << endl;
 cout << " *" << ClassName() << "::WriteBurstHistograms* All generated histograms have been written to file " << filename << endl;
 ListBurstHistograms();
}

void NcAstrolab::SkyMapPanel()
{
 
 if (gROOT->IsBatch())
 {
  printf("\n *%-s::SkyMapPanel* GUI is not available in batch mode. \n",ClassName());
  return;
 }
 
 // Select the lab timestamp as default
 fMapTS.SetMJD(fMJD,fJsec,fJns,fJps,"A");
 
 // Import current Lab settings
 Double_t l=0;
 Double_t b=0;
 GetLabPosition(l,b,"deg");
 fMapLabLocL=l;
 fMapLabLocB=b;
 fMapLabExpName=GetExperiment();
 fMapLabId=fLabId;
 // Get the lab timestamp data in the text box
 UInt_t year=0;
 UInt_t month=0;
 UInt_t day=0;
 GetDate(kTRUE,0,&year,&month,&day);
 GetDayTimeString("UTC",3,0,0,&fMapTime);
 fMapDate.Form("%02i-%02i-%-i",day,month,year);
 fMapTime.ReplaceAll(" UTC","");
 fMapDateTime=fMapDate;
 fMapDateTime+="/";
 fMapDateTime+=fMapTime;
 
 // Re-invokation of the SkyMapPanel
 if (fSkyMapPanel)
 {
  // Import the current lab settings
  Int_t idx=1;
  TString names[9]={"User","IceCube","RNO-G","ARA","Amanda","WSRT","Astron","Greenwich","ARCA"};
  for (Int_t i=1; i<=9; i++)
  {
   if (names[i-1]==fExperiment) idx=i;
  }
  fMapLabE->Select(idx,kTRUE);
 
  MapLocEnter();
 
  // The Lab UTC time
  fMapTStimetype->Select(1,kTRUE);
  MapTimeType(10);
 
  // Map all subwindows of main frame
  fSkyMapPanel->MapSubwindows();
 
  // Initialize the layout algorithm
  fSkyMapPanel->Resize(fSkyMapPanel->GetDefaultSize());
 
  // Map main frame
  fSkyMapPanel->MapWindow();
  
  return;
 }
 
 // New initialization of the SkyMapPanel
 UInt_t border=5;
 fSkyMapPanel=new TGMainFrame(gClient->GetRoot());
 fSkyMapPanel->SetWindowName("SkyMapPanel");
 fSkyMapPanel->Connect("CloseWindow()","NcAstrolab",this,"MapClose()");
 
 // Define the various sub-frames and fill them with the various panels 
 TGCompositeFrame* frames[4]={0,0,0,0};
 TGLayoutHints* layouts[4]={0,0,0,0};
 
 // The Lab specification and timestamp frame
 frames[0]=new TGCompositeFrame(fSkyMapPanel,1,1,kHorizontalFrame|kSunkenFrame);
 layouts[0]=new TGLayoutHints(kLHintsExpandX,border,border,0,0);
 LabLocationPanel(frames[0]);
 TimestampPanel(frames[0]);
 
 // The local reference and info frame
 frames[1]=new TGCompositeFrame(fSkyMapPanel,1,1,kHorizontalFrame|kSunkenFrame);
 layouts[1]=new TGLayoutHints(kLHintsExpandX,border,border,0,0);
 LabLocalFramePanel(frames[1]);
 InfoPanel(frames[1]);
 
 // The entries frame
 frames[2]=new TGCompositeFrame(fSkyMapPanel,1,1,kHorizontalFrame|kSunkenFrame);
 layouts[2]=new TGLayoutHints(kLHintsExpandX,border,border,0,0);
 EntriesPanel(frames[2]);
 
 // The drawing/listing options and command buttons frame
 frames[3]=new TGCompositeFrame(fSkyMapPanel,1,1,kHorizontalFrame|kSunkenFrame);
 layouts[3]=new TGLayoutHints(kLHintsExpandX,border,border,0,0);
 MapListOptionsPanel(frames[3]);
 CommandPanel(frames[3]);
 
 // Add all subframes to the mainframe
 for (Int_t i=0; i<4; i++)
 {
  if (frames[i]) fSkyMapPanel->AddFrame(frames[i],layouts[i]);
 }
 
 // Map all subwindows of main frame
 fSkyMapPanel->MapSubwindows();
 
 // Initialize the layout algorithm
 fSkyMapPanel->Resize(fSkyMapPanel->GetDefaultSize());
 
 // Map main frame
 fSkyMapPanel->MapWindow();
}

void NcAstrolab::LabLocationPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Lab longitude, latitude, experiment site and detector ID",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // The lab longitude entry field
 fMapLabLBI[0]=new TGNumberEntryField(panel,-1,fMapLabLocL);
 fMapLabLBI[0]->SetToolTipText("Longitude");
 fMapLabLBI[0]->Connect("TextChanged(const char*)","NcAstrolab",this,"MapLocl(const char*)");
 fMapLabLBI[0]->Resize(65,20);
 panel->AddFrame(fMapLabLBI[0]);
 
 // The lab latitude entry field
 fMapLabLBI[1]=new TGNumberEntryField(panel,-1,fMapLabLocB);
 fMapLabLBI[1]->SetToolTipText("Latitude");
 fMapLabLBI[1]->Connect("TextChanged(const char*)","NcAstrolab",this,"MapLocb(const char*)");
 fMapLabLBI[1]->Resize(65,20);
 panel->AddFrame(fMapLabLBI[1]);
 
 // The lab longitude and latitude type selection box
 fMapLabU=new TGComboBox(panel);
 fMapLabU->Connect("Selected(Int_t)","NcAstrolab",this,"MapUloc(Int_t)");
 fMapLabU->AddEntry("deg",1);
 fMapLabU->AddEntry("dms",2);
 fMapLabU->AddEntry("hms",3);
 fMapLabU->AddEntry("rad",4);
 fMapLabU->Resize(50,20);
 panel->AddFrame(fMapLabU);
 fMapLabU->Select(1,kTRUE);
 
 // The experiment name selection box
 fMapLabE=new TGComboBox(panel);
 fMapLabE->Connect("Selected(Int_t)","NcAstrolab",this,"MapExperiment(Int_t)");
 Int_t idx=1;
 TString names[9]={"User","IceCube","RNO-G","ARA","Amanda","WSRT","Astron","Greenwich","ARCA"};
 for (Int_t i=1; i<=9; i++)
 {
  fMapLabE->AddEntry(names[i-1],i);
  if (names[i-1]==fExperiment) idx=i;
 }
 fMapLabE->Resize(90,20);
 panel->AddFrame(fMapLabE);
 fMapLabE->Select(idx,kTRUE);
 
 // The detector element ID field
 fMapLabLBI[2]=new TGNumberEntryField(panel,-1,fLabId,TGNumberFormat::kNESInteger);
 fMapLabLBI[2]->SetToolTipText("The (optional) detector element ID (0=global)");
 fMapLabLBI[2]->Connect("TextChanged(const char*)","NcAstrolab",this,"MapLocId(const char*)");
 fMapLabLBI[2]->Resize(40,20);
 panel->AddFrame(fMapLabLBI[2]);
 
 // The button to enter the provided data
 TGTextButton* enter=new TGTextButton(panel,"Enter");
 enter->SetToolTipText("Enter the provided data");
 enter->Connect("Clicked()","NcAstrolab",this,"MapLocEnter()");
 TGLayoutHints* Lenter=new TGLayoutHints(kLHintsCenterX,10,0,0,0);
 panel->AddFrame(enter,Lenter);
 
 MapLocEnter();
}

void NcAstrolab::MapLocl(const char* text)
{
 
 TString s=text;
 fMapLabLocL=s.Atof();
}

void NcAstrolab::MapLocb(const char* text)
{
 
 TString s=text;
 fMapLabLocB=s.Atof();
}

void NcAstrolab::MapUloc(Int_t i)
{
 
 TString s[4]={"deg","dms","hms","rad"};
 if (i<=4) fMapLabLocU=s[i-1];
}

void NcAstrolab::MapExperiment(Int_t i)
{
 
 TString s[9]={"User","IceCube","RNO-G","ARA","Amanda","WSRT","Astron","Greenwich","ARCA"};
 if (i<=9) fMapLabExpName=s[i-1];
}

void NcAstrolab::MapLocId(const char* text)
{
 
 TString s=text;
 fMapLabId=s.Atoi();
}

void NcAstrolab::MapLocEnter()
{
 
 fSkyMapPanel->RequestFocus();
 
 SetLabPosition(fMapLabLocL,fMapLabLocB,fMapLabLocU);
 
 if (fMapLabExpName=="User")
 {
  SetNameTitle("User","Virtual Lab for general use");
  MapLocId("0");
  printf("\n *** Settings adopted for a virtual lab for general use. *** \n");
 }
 else
 {
  SetExperiment(fMapLabExpName,fMapLabId);
  fMapLabId=GetLabDetectorId();
  // Update the longitude, latitude and detector ID  selection boxes
  GetLabPosition(fMapLabLocL,fMapLabLocB,"deg");
  TString s;
  s.Form("%-.3f",fMapLabLocL);
  fMapLabLBI[0]->SetText(s);
  s.Form("%-.3f",fMapLabLocB);
  fMapLabLBI[1]->SetText(s);
  fMapLabU->Select(1,kTRUE);
  MapUloc(1);
  s.Form("%-i",fMapLabId);
  fMapLabLBI[2]->SetText(s);
  printf("\n *** Lab settings adopted for the %-s location. *** \n",fMapLabExpName.Data());
 }
 
 // Update the local frame data for the selected lab
 TString val;
 for (Int_t i=0; i<6; i++)
 {
  val.Form("%-.2f",fAxes[i]);
  if (fMapLabLframe[i]) fMapLabLframe[i]->SetText(val);
 }
}

void NcAstrolab::TimestampPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Timestamp to be used for Entries, List and Map",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // The Date/Time textbox
 fMapTSdatetime=new TGTextEntry(panel,fMapDateTime.Data());
 fMapTSdatetime->SetToolTipText("Date/Time as dd-mm-yyyy/hh:mm:ss.sss or MJD");
 fMapTSdatetime->Connect("TextChanged(const char*)","NcAstrolab",this,"MapDateTime(const char*)");
 fMapTSdatetime->SetAlignment(kTextRight);
 fMapTSdatetime->Resize(170,20);
 panel->AddFrame(fMapTSdatetime);
 
 // The Time type selection box
 fMapTStimetype=new TGComboBox(panel);
 fMapTStimetype->Connect("Selected(Int_t)","NcAstrolab",this,"MapTimeType(Int_t)");
 fMapTStimetype->AddEntry("UTC",1);
 fMapTStimetype->AddEntry("LMT",2);
 fMapTStimetype->AddEntry("UT1",3);
 fMapTStimetype->AddEntry("MJD",4);
 fMapTStimetype->AddEntry("JD",5);
 fMapTStimetype->AddEntry("TJD",6);
 fMapTStimetype->AddEntry("Unix",7);
 fMapTStimetype->AddEntry("GPS",8);
 fMapTStimetype->AddEntry("TAI",9);
 fMapTStimetype->AddEntry("TT",10);
 fMapTStimetype->AddEntry("SysClock",11);
 fMapTStimetype->AddEntry("Lab",12);
 fMapTStimetype->AddEntry("EntryName",13);
 fMapTStimetype->Resize(100,20);
 panel->AddFrame(fMapTStimetype);
 fMapTStimetype->Select(1,kTRUE);
 MapTimeType(1);
 
 // The Lab TS modification button
 TGTextButton* labTS=new TGTextButton(panel,"Store as Lab TS");
 labTS->SetToolTipText("Store the current selection as Lab timestamp");
 labTS->Connect("Clicked()","NcAstrolab",this,"MapLabTS()");
 TGLayoutHints* LlabTS=new TGLayoutHints(kLHintsCenterX,10,0,0,0);
 panel->AddFrame(labTS,LlabTS);
}

void NcAstrolab::MapDateTime(const char* text)
{
 
 fMapDateTime=text;
}

void NcAstrolab::MapTimeType(Int_t i)
{
 
 TString s[13]={"UTC","LMT","UT1","MJD","JD","TJD","Unix","GPS","TAI","TT","SysClock","Lab","EntryName"};
 
 if (i<=13) fMapTimeType=s[i-1];
 
 if (fMapTimeType=="SysClock" || fMapTimeType=="Lab") SetMapTS();
 if (fMapTimeType=="MJD" || fMapTimeType=="JD" || fMapTimeType=="TJD" || fMapTimeType=="Unix" || fMapTimeType.Contains("Name")) fMapTSdatetime->SetText("");
}

void NcAstrolab::MapLabTS()
{
 
 SetMapTS();
 
 fSkyMapPanel->RequestFocus();
 
 Int_t mjd,sec,ns;
 fMapTS.GetMJD(mjd,sec,ns);
 Int_t ps=fMapTS.GetPs();
 this->SetMJD(mjd,sec,ns,ps,"U");
 
 printf("\n *** Lab timestamp modified *** \n");
}

void NcAstrolab::LabLocalFramePanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Local frame axes orientations w.r.t. X0=South, Y0=East, Z0=Zenith)",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // The local X-axis theta (=zenith) angle w.r.t. the MRF
 fMapLabLframe[0]=new TGNumberEntryField(panel,-1,fAxes[0]);
 fMapLabLframe[0]->SetToolTipText("Local X-axis zenith angle in deg");
 fMapLabLframe[0]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[0]);
 
 // The local X-axis phi angle w.r.t. the MRF
 fMapLabLframe[1]=new TGNumberEntryField(panel,-1,fAxes[1]);
 fMapLabLframe[1]->SetToolTipText("Local X-axis phi angle in deg");
 fMapLabLframe[1]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[1]);
 
 // The local Y-axis theta (=zenith) angle w.r.t. the MRF
 fMapLabLframe[2]=new TGNumberEntryField(panel,-1,fAxes[2]);
 fMapLabLframe[2]->SetToolTipText("Local Y-axis zenith angle in deg");
 fMapLabLframe[2]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[2]);
 
 // The local Y-axis phi angle w.r.t. the MRF
 fMapLabLframe[3]=new TGNumberEntryField(panel,-1,fAxes[3]);
 fMapLabLframe[3]->SetToolTipText("Local Y-axis phi angle in deg");
 fMapLabLframe[3]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[3]);
 
 // The local Z-axis theta (=zenith) angle w.r.t. the MRF
 fMapLabLframe[4]=new TGNumberEntryField(panel,-1,fAxes[4]);
 fMapLabLframe[4]->SetToolTipText("Local Z-axis zenith angle in deg");
 fMapLabLframe[4]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[4]);
 
 // The local Z-axis phi angle w.r.t. the MRF
 fMapLabLframe[5]=new TGNumberEntryField(panel,-1,fAxes[5]);
 fMapLabLframe[5]->SetToolTipText("Local Z-axis phi angle in deg");
 fMapLabLframe[5]->Resize(55,20);
 panel->AddFrame(fMapLabLframe[5]);
 
 MapLabLframeEnter();
 
 // The button to enter the provided data
 TGTextButton* enter=new TGTextButton(panel,"Enter");
 enter->SetToolTipText("Enter the provided data");
 enter->Connect("Clicked()","NcAstrolab",this,"MapLabLframeEnter()");
 TGLayoutHints* Lenter=new TGLayoutHints(kLHintsLeft,10,0,0,0);
 panel->AddFrame(enter,Lenter);
}

void NcAstrolab::MapLabLframeEnter()
{
 
 fSkyMapPanel->RequestFocus();
 
 if (fMapLabExpName=="IceCube" || fMapLabExpName=="RNO-G" || fMapLabExpName=="Amanda")
 {
  printf("\n *** Local frame will NOT be changed for experiment site %-s *** \n",fMapLabExpName.Data());
 
  // Update the local frame data for the selected lab
  TString val;
  for (Int_t i=0; i<6; i++)
  {
   val.Form("%-.2f",fAxes[i]);
   if (fMapLabLframe[i]) fMapLabLframe[i]->SetText(val);
  }
  return;
 }
 
 for (Int_t i=0; i<6; i++)
 {
  fAxes[i]=fMapLabLframe[i]->GetNumber();
 }
 
 SetLocalFrame(fAxes[0],fAxes[1],fAxes[2],fAxes[3],fAxes[4],fAxes[5]);
}

void NcAstrolab::InfoPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Informative output",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // The info category selection box
 TGComboBox* cinfo=new TGComboBox(panel);
 cinfo->Connect("Selected(Int_t)","NcAstrolab",this,"MapCinfo(Int_t)");
 cinfo->AddEntry("Lab",1);
 cinfo->AddEntry("TSbox",2);
 cinfo->AddEntry("Entry",3);
 cinfo->AddEntry("Nstore",4);
 cinfo->Resize(60,20);
 panel->AddFrame(cinfo);
 cinfo->Select(1,kTRUE);
 MapCinfo(1);
 
 // The lab info time type selection box
 TGComboBox* tinfo=new TGComboBox(panel);
 tinfo->Connect("Selected(Int_t)","NcAstrolab",this,"MapTinfo(Int_t)");
 tinfo->AddEntry("LAT/LAST",1);
 tinfo->AddEntry("LMT/LMST",2);
 tinfo->AddEntry("Julian",3);
 tinfo->AddEntry("UT1",4);
 tinfo->AddEntry("UTC",5);
 tinfo->AddEntry("TAI",6);
 tinfo->AddEntry("GPS",7);
 tinfo->AddEntry("TT",8);
 tinfo->AddEntry("Unix",9);
 tinfo->Resize(85,20);
 panel->AddFrame(tinfo);
 tinfo->Select(1,kTRUE);
 MapTinfo(1);
 
 // The lab info longitude and latitude type selection box
 TGComboBox* uinfo=new TGComboBox(panel);
 uinfo->Connect("Selected(Int_t)","NcAstrolab",this,"MapUinfo(Int_t)");
 uinfo->AddEntry("deg",1);
 uinfo->AddEntry("dms",2);
 uinfo->AddEntry("hms",3);
 uinfo->AddEntry("rad",4);
 uinfo->Resize(50,20);
 panel->AddFrame(uinfo);
 uinfo->Select(1,kTRUE);
 MapUinfo(1);
 
 // The entry name textbox
 TGTextEntry* mapiname=new TGTextEntry(panel,"");
 mapiname->SetToolTipText("Stored entry name for info");
 mapiname->Connect("TextChanged(const char*)","NcAstrolab",this,"MapIname(const char*)");
 mapiname->SetAlignment(kTextRight);
 mapiname->Resize(100,20);
 panel->AddFrame(mapiname);
 
 // The info button
 TGTextButton* info=new TGTextButton(panel,"Info");
 info->Connect("Clicked()","NcAstrolab",this,"MapInfo()");
 info->SetToolTipText("Provide info on the specified item");
 TGLayoutHints* Linfo=new TGLayoutHints(kLHintsLeft,10,0,0,0);
 panel->AddFrame(info,Linfo);
}

void NcAstrolab::MapCinfo(Int_t i)
{
 
 TString s[4]={"Lab","TS box","EntryName","Nstore"};
 if (i<=4) fMapCinfo=s[i-1];
}

void NcAstrolab::MapTinfo(Int_t i)
{
 
 if (i==1)
 {
  fMapTinfo=-1;
 }
 else
 {
  fMapTinfo=i-1;
 }
}

void NcAstrolab::MapUinfo(Int_t i)
{
 
 TString s[4]={"deg","dms","hms","rad"};
 if (i<=4) fMapUinfo=s[i-1];
}

void NcAstrolab::MapIname(const char* text)
{
 
 fMapIname=text; 
}

void NcAstrolab::MapInfo()
{
 
 SetMapTS();
 
 TString modes[9]={"LAT/LAST","LMT/LMST","Julian","UT1","UTC","TAI","GPS","TT","Unix"};
 TString datetime;
 
 if (fMapCinfo=="Nstore")
 {
  Int_t nref=GetNsignals(0);
  Int_t nmeas=GetNsignals(1);
  Int_t ntot=nref+nmeas;
  printf("\n *** Info about the stored entries *** \n");
  printf(" Ntotal=%-i Nrefs=%-i Nmeas=%-i \n",ntot,nref,nmeas);
 }
 else if (fMapCinfo=="Lab")
 {
  if (fMapTinfo<3)
  {
   printf("\n *** Info about the current Lab settings *** \n");
   Data(fMapTinfo,fMapUinfo);
  }
  else
  {
   printf("\n *** Info for the Lab timestamp *** \n");
   if (fMapTinfo==8)
   {
    printf(" Unix time : %-.12f \n",GetUnixTime());
   }
   else
   {
    datetime=GetDayTimeString(modes[fMapTinfo],12);
    printf(" %-s \n",datetime.Data());
   }
  }
 }
 else if (fMapCinfo.Contains("TS"))
 {
  printf("\n *** Info for the timestamp in the user selection box *** \n");
  if (fMapTinfo<3)
  {
   printf(" Lab time offset w.r.t. UT : "); PrintTime(fToffset,12); printf("\n");
   fMapTS.Date(fMapTinfo,fToffset);
   fMapTS.Date(4);
  }
  else
  {
   if (fMapTinfo==8)
   {
    printf(" Unix time : %-.12f \n",fMapTS.GetUnixTime());
   }
   else
   {
    datetime=fMapTS.GetDayTimeString(modes[fMapTinfo],12);
    printf(" %-s \n",datetime.Data());
   }
  }
 }
 else // Information of the specified entry name
 {
  NcSignal* sx=0;
  NcTimestamp* tx=0;
  sx=GetSignal(fMapIname,0);
  if(!sx) sx=GetSignal(fMapIname,1);
  if (sx)
  {
   printf("\n *** Info for entry : %-s *** \n",fMapIname.Data());
   sx->Data("sph",fMapUinfo);
   tx=sx->GetTimestamp();
   if (tx)
   {
    NcTimestamp tx2(*tx);
    tx2.LoadUTCparameterFiles();
    if (fMapTinfo<3)
    {
     printf(" Lab time offset w.r.t. UT : "); PrintTime(fToffset,12); printf("\n");
     tx2.Date(fMapTinfo,fToffset);
     tx2.Date(4);
    }
    else
    {
     if (fMapTinfo==8)
     {
      printf(" Unix time : %-.12f \n",tx2.GetUnixTime());
     }
     else
     {
      datetime=tx2.GetDayTimeString(modes[fMapTinfo],12);
      printf(" %-s \n",datetime.Data());
     }
    }
   }
  }
  else
  {
   printf("\n *** No entry found with name : %-s *** \n",fMapIname.Data());
  }
 }
}

void NcAstrolab::EntriesPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Entries in (a,b) coordinates",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // The a coordinate entry field
 TGNumberEntryField* ea=new TGNumberEntryField(panel,-1,0);
 ea->SetToolTipText("Angle a");
 ea->Connect("TextChanged(const char*)","NcAstrolab",this,"MapEa(const char*)");
 ea->Resize(100,20);
 panel->AddFrame(ea);
 MapEa("0");
 
 // The a coordinate type selection box
 TGComboBox* ua=new TGComboBox(panel);
 ua->Connect("Selected(Int_t)","NcAstrolab",this,"MapUa(Int_t)");
 ua->AddEntry("deg",1);
 ua->AddEntry("dms",2);
 ua->AddEntry("hms",3);
 ua->AddEntry("rad",4);
 ua->AddEntry("hrs",5);
 ua->Resize(50,20);
 panel->AddFrame(ua);
 ua->Select(1,kTRUE);
 MapUa(1);
 
 // The b coordinate entry field
 TGNumberEntryField* eb=new TGNumberEntryField(panel,-1,0);
 eb->SetToolTipText("Angle b");
 eb->Connect("TextChanged(const char*)","NcAstrolab",this,"MapEb(const char*)");
 eb->Resize(100,20);
 panel->AddFrame(eb);
 MapEb("0");
 
 // The b coordinate type selection box
 TGComboBox* ub=new TGComboBox(panel);
 ub->Connect("Selected(Int_t)","NcAstrolab",this,"MapUb(Int_t)");
 ub->AddEntry("deg",1);
 ub->AddEntry("dms",2);
 ub->AddEntry("hms",3);
 ub->AddEntry("rad",4);
 ub->AddEntry("hrs",5);
 ub->Resize(50,20);
 panel->AddFrame(ub);
 ub->Select(1,kTRUE);
 MapUb(1);
 
 TGComboBox* ecoords=new TGComboBox(panel);
 ecoords->Connect("Selected(Int_t)","NcAstrolab",this,"MapEcoord(Int_t)");
 ecoords->AddEntry("(ra,dec) (J2000)",1);
 ecoords->AddEntry("(ra,dec) (Mean)",2);
 ecoords->AddEntry("(ra,dec) (True)",3);
 ecoords->AddEntry("(ra,dec) (B1950)",4);
 ecoords->AddEntry("Galactic (l,b)",5);
 ecoords->AddEntry("Ecliptic (l,b)",6);
 ecoords->AddEntry("Horizon (azi,zen)",7);
 ecoords->AddEntry("ICR (l,b)",8);
 ecoords->AddEntry("Local (theta,phi)",9);
 ecoords->AddEntry("pdir (theta,phi)",10);
 ecoords->Resize(125,20);
 panel->AddFrame(ecoords);
 ecoords->Select(1,kTRUE);
 MapEcoord(1);
 
 // The signal type
 TGComboBox* etypes=new TGComboBox(panel);
 etypes->Connect("Selected(Int_t)","NcAstrolab",this,"MapEtype(Int_t)");
 etypes->AddEntry("Meas",1);
 etypes->AddEntry("Ref",2);
 etypes->Resize(55,20);
 panel->AddFrame(etypes);
 etypes->Select(1,kTRUE);
 MapEtype(1);
 
 // The (optional) signal name
 TGTextEntry* ename=new TGTextEntry(panel,"");
 ename->SetToolTipText("The (optional) entry name");
 ename->Connect("TextChanged(const char*)","NcAstrolab",this,"MapEname(const char*)");
 ename->SetAlignment(kTextRight);
 ename->Resize(100,20);
 panel->AddFrame(ename);
 
 // The button to Enter the entry
 TGTextButton* enter=new TGTextButton(panel,"Enter");
 enter->SetToolTipText("Enter the provided entry");
 enter->Connect("Clicked()","NcAstrolab",this,"MapEnter()");
 TGLayoutHints* Lenter=new TGLayoutHints(kLHintsCenterX,10,0,0,0);
 panel->AddFrame(enter,Lenter);
 
 // The button to Remove the entry
 TGTextButton* remove=new TGTextButton(panel,"Remove");
 remove->SetToolTipText("Remove the entry specified by type and name pattern (name=* means all)");
 remove->Connect("Clicked()","NcAstrolab",this,"MapRemove()");
 TGLayoutHints* Lremove=new TGLayoutHints(kLHintsCenterX,10,0,0,0);
 panel->AddFrame(remove,Lremove);
}

void NcAstrolab::MapEa(const char* text)
{
 
 TString s=text;
 fMapEa=s.Atof();
}

void NcAstrolab::MapUa(Int_t i)
{
 
 TString s[5]={"deg","dms","hms","rad","hrs"};
 if (i<=5) fMapEua=s[i-1];
}

void NcAstrolab::MapEb(const char* text)
{
 
 TString s=text;
 fMapEb=s.Atof();
}

void NcAstrolab::MapUb(Int_t i)
{
 
 TString s[5]={"deg","dms","hms","rad","hrs"};
 if (i<=5) fMapEub=s[i-1];
}

void NcAstrolab::MapEcoord(Int_t i)
{
 
 TString system[10]={"equ","equ","equ","equ","gal","ecl","hor","icr","loc","pdir"};
 TString mode[4]={"J","M","T","B"};
 
 if (i<=10) fMapEcoord=system[i-1];
 
 if (i<=4) fMapEmode=mode[i-1];
}

void NcAstrolab::MapEtype(Int_t i)
{
 
 fMapEtype=1;
 if (i==2) fMapEtype=0;
}

void NcAstrolab::MapEname(const char* text)
{
 
 fMapEname=text;
}

void NcAstrolab::MapEnter()
{
 
 SetMapTS(); // Set the selected timestamp
 
 fSkyMapPanel->RequestFocus();
 
 SetSignal(1,fMapEa,fMapEua,fMapEb,fMapEub,fMapEcoord,&fMapTS,-1,fMapEmode,fMapEname,fMapEtype);
 
 printf("\n *** Specified entry stored *** \n");
}

void NcAstrolab::MapRemove()
{
 
 SetMapTS(); // Set the selected timestamp
 
 fSkyMapPanel->RequestFocus();
 
 Int_t nrem=0;
 nrem=RemoveSignals(fMapEname,fMapEtype,1);
 
 printf("\n *** Number of specified entries have been removed : %-i *** \n",nrem);
}

void NcAstrolab::MapListOptionsPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Map/List options for the (a,b) coordinates",kHorizontalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 // A frame with various additional settings
 TGVerticalFrame* render=new TGVerticalFrame(panel,1,1);
 panel->AddFrame(render);
 
 // The coordinate system selection box
 TGGroupFrame* coordsys=new TGGroupFrame(render,"Coordinate system",kHorizontalFrame);
 coordsys->SetTitlePos(TGGroupFrame::kCenter);
 render->AddFrame(coordsys);
 TGComboBox* dcoords=new TGComboBox(coordsys);
 dcoords->Connect("Selected(Int_t)","NcAstrolab",this,"MapDcoord(Int_t)");
 dcoords->AddEntry("Equatorial (J2000)",1);
 dcoords->AddEntry("Equatorial (Mean)",2);
 dcoords->AddEntry("Equatorial (True)",3);
 dcoords->AddEntry("Equatorial (B1950)",4);
 dcoords->AddEntry("Galactic",5);
 dcoords->AddEntry("Ecliptic",6);
 dcoords->AddEntry("Horizon",7);
 dcoords->AddEntry("ICR",8);
 dcoords->AddEntry("Local",9);
 dcoords->Resize(140,20);
 coordsys->AddFrame(dcoords);
 dcoords->Select(1,kTRUE);
 MapDcoord(1);
 
 // The Map representation selection box
 TGGroupFrame* mapview=new TGGroupFrame(render,"Map representation",kHorizontalFrame);
 mapview->SetTitlePos(TGGroupFrame::kCenter);
 render->AddFrame(mapview);
 TGComboBox* projs=new TGComboBox(mapview);
 projs->Connect("Selected(Int_t)","NcAstrolab",this,"MapProj(Int_t)");
 projs->AddEntry("Hammer projection",1);
 projs->AddEntry("Aitoff projection",2);
 projs->AddEntry("Mercator projection",3);
 projs->AddEntry("sin(b) vs. a",4);
 projs->AddEntry("b vs. a",5);
 projs->AddEntry("b vs. UT (0-24 hrs)",6);
 projs->AddEntry("b vs. LT (0-24 hrs)",7);
 projs->AddEntry("b vs. GST (0-24 hrs)",8);
 projs->AddEntry("b vs. LST (0-24 hrs)",9);
 projs->AddEntry("b vs. Day at UT",10);
 projs->AddEntry("b vs. Day at LT",11);
 projs->AddEntry("b vs. Day at GST",12);
 projs->AddEntry("b vs. Day at LST",13);
 projs->Resize(150,20);
 mapview->AddFrame(projs);
 projs->Select(1,kTRUE);
 MapProj(1);
 
 // The meridian representation options
 TGGroupFrame* meridian=new TGGroupFrame(render,"Meridian ordering",kHorizontalFrame);
 meridian->SetTitlePos(TGGroupFrame::kCenter);
 render->AddFrame(meridian);
 
 // The meridian mode selection box
 TGComboBox* mermode=new TGComboBox(meridian);
 mermode->Connect("Selected(Int_t)","NcAstrolab",this,"MapMerMode(Int_t)");
 mermode->AddEntry("Auto",1);
 mermode->AddEntry("---->",2);
 mermode->AddEntry("<----",3);
 mermode->Resize(55,20);
 meridian->AddFrame(mermode);
 mermode->Select(1,kTRUE);
 MapMerMode(1);
 
 // The meridian central value
 TGNumberEntryField* merc=new TGNumberEntryField(meridian,-1,0);
 merc->SetToolTipText("Central meridian position");
 merc->Connect("TextChanged(const char*)","NcAstrolab",this,"MapMerC(const char*)");
 merc->Resize(65,20);
 meridian->AddFrame(merc);
 MapMerC("0");
 
 // The meridian central value type selection box
 TGComboBox* meruc=new TGComboBox(meridian);
 meruc->Connect("Selected(Int_t)","NcAstrolab",this,"MapMerUc(Int_t)");
 meruc->AddEntry("deg",1);
 meruc->AddEntry("dms",2);
 meruc->AddEntry("hms",3);
 meruc->AddEntry("rad",4);
 meruc->Resize(50,20);
 meridian->AddFrame(meruc);
 meruc->Select(1,kTRUE);
 MapMerUc(1);
 
 // The options group
 TGVButtonGroup* options=new TGVButtonGroup(panel,"Options");
 options->SetTitlePos(TGGroupFrame::kCenter);
 options->Connect("Clicked(Int_t)","NcAstrolab",this,"MapDoptions(Int_t)");
 TGCheckButton* bhist=new TGCheckButton(options,"Hist");
 bhist->SetToolTipText("Project data in a histogram");
 TGCheckButton* bclr=new TGCheckButton(options,"Clr");
 bclr->SetToolTipText("Clear display before drawing");
 TGCheckButton* bref=new TGCheckButton(options,"Ref");
 bref->SetToolTipText("Display reference signals");
 TGCheckButton* bmeas=new TGCheckButton(options,"Meas");
 bmeas->SetToolTipText("Display measured signals");
 TGCheckButton* brefts=new TGCheckButton(options,"RefTS");
 brefts->SetToolTipText("Display/list each reference signal using its actual recorded timestamp");
 panel->AddFrame(options);
 options->Show();
 options->SetButton(1,kFALSE);
 options->SetButton(2,kTRUE);
 options->SetButton(3,kTRUE);
 options->SetButton(4,kTRUE);
 options->SetButton(5,kFALSE);
 fMapDoptions[0]=kFALSE;
 fMapDoptions[1]=kTRUE;
 fMapDoptions[2]=kTRUE;
 fMapDoptions[3]=kTRUE;
 fMapDoptions[4]=kFALSE;
 
 // The Nmax entry field
 TGNumberEntryField* nmax=new TGNumberEntryField(options,-1,-1,TGNumberFormat::kNESInteger);
 nmax->SetToolTipText("Max. number of Drawn/Listed entries per type (-1=all)");
 nmax->Connect("TextChanged(const char*)","NcAstrolab",this,"MapNmax(const char*)");
 nmax->Resize(40,20);
 options->AddFrame(nmax);
 MapNmax("-1");
 
 // The signal name pattern for matching
 TGTextEntry* sname=new TGTextEntry(options,"*");
 sname->SetToolTipText("The requested entry name pattern (*=all)");
 sname->Connect("TextChanged(const char*)","NcAstrolab",this,"MapDname(const char*)");
 sname->SetAlignment(kTextRight);
 sname->Resize(100,20);
 TGLayoutHints* Lsname=new TGLayoutHints(kLHintsLeft,0,0,5,0);
 options->AddFrame(sname,Lsname);
 MapDname("*");
 
 // The Ndigs entry field
 TGNumberEntryField* ndigs=new TGNumberEntryField(options,-1,1,TGNumberFormat::kNESInteger);
 ndigs->SetToolTipText("Number of digits for the listed entries");
 ndigs->Connect("TextChanged(const char*)","NcAstrolab",this,"MapNdigs(const char*)");
 ndigs->Resize(40,20);
 options->AddFrame(ndigs);
 MapNdigs("1");
 
 // A frame with various additional settings
 TGVerticalFrame* others=new TGVerticalFrame(panel,1,1);
 panel->AddFrame(others);
 
 // The Marker size frame
 TGGroupFrame* markers=new TGGroupFrame(others,"Marker settings",kHorizontalFrame);
 markers->SetTitlePos(TGGroupFrame::kCenter);
 others->AddFrame(markers);
 
 // The marker size
 TGNumberEntryField* marksize=new TGNumberEntryField(markers,-1,1);
 marksize->SetToolTipText("Marker size");
 marksize->Connect("TextChanged(const char*)","NcAstrolab",this,"MapMarkSize(const char*)");
 marksize->Resize(40,20);
 markers->AddFrame(marksize);
 MapMarkSize("1");
 
 // The marker style
 TGComboBox* markstyle=new TGComboBox(markers);
 markstyle->Connect("Selected(Int_t)","NcAstrolab",this,"MapMarkStyle(Int_t)");
 markstyle->AddEntry("Dot",1);
 markstyle->AddEntry("Star",2);
 markstyle->AddEntry("Square",3);
 markstyle->AddEntry("Utriangle",4);
 markstyle->AddEntry("Dtriangle",5);
 markstyle->AddEntry("Diamond",6);
 markstyle->AddEntry("Cross",7);
 markstyle->AddEntry("Ast",8);
 markstyle->AddEntry("Plus",9);
 markstyle->AddEntry("Times",10);
 markstyle->AddEntry("Circle",11);
 markstyle->AddEntry("oStar",12);
 markstyle->AddEntry("oSquare",13);
 markstyle->AddEntry("oUtriangle",14);
 markstyle->AddEntry("oDtriangle",15);
 markstyle->AddEntry("oDiamond",16);
 markstyle->AddEntry("oCross",17);
 markstyle->Resize(90,20);
 markers->AddFrame(markstyle);
 markstyle->Select(1,kTRUE);
 MapMarkStyle(1);
 
 // The marker color selection box
 TGComboBox* markcolor=new TGComboBox(markers);
 markcolor->Connect("Selected(Int_t)","NcAstrolab",this,"MapMarkColor(Int_t)");
 markcolor->AddEntry("Black",1);
 markcolor->AddEntry("Red",2);
 markcolor->AddEntry("Blue",3);
 markcolor->AddEntry("Green",4);
 markcolor->AddEntry("Yellow",5);
 markcolor->AddEntry("Magenta",6);
 markcolor->AddEntry("Cyan",7);
 markcolor->AddEntry("Orange",8);
 markcolor->AddEntry("Violet",9);
 markcolor->AddEntry("Pink",10);
 markcolor->AddEntry("Azure",11);
 markcolor->AddEntry("Spring",12);
 markcolor->AddEntry("Teal",13);
 markcolor->AddEntry("Gray",14);
 markcolor->AddEntry("White",15);
 markcolor->Resize(80,20);
 markers->AddFrame(markcolor);
 markcolor->Select(3,kTRUE);
 MapMarkColor(3);
 
 // The marker type selection box
 TGComboBox* marktype=new TGComboBox(markers);
 marktype->Connect("Selected(Int_t)","NcAstrolab",this,"MapMarkType(Int_t)");
 marktype->AddEntry("Ref",1);
 marktype->AddEntry("Meas",2);
 marktype->AddEntry("GC",3);
 marktype->AddEntry("Grid",4);
 marktype->Resize(55,20);
 markers->AddFrame(marktype);
 marktype->Select(2,kTRUE);
 MapMarkType(2);
 
 // The Solar system group
 TGGroupFrame* solar=new TGGroupFrame(others,"Selection of Solar system reference objects",kHorizontalFrame);
 solar->SetTitlePos(TGGroupFrame::kCenter);
 others->AddFrame(solar);
 
 TGButtonGroup* Ssolar=new TGButtonGroup(solar,0,3,5);
 Ssolar->SetTitlePos(TGGroupFrame::kCenter);
 Ssolar->Connect("Clicked(Int_t)","NcAstrolab",this,"MapSolar(Int_t)");
 TGCheckButton* bsun=new TGCheckButton(Ssolar,"Sun");
 bsun->SetToolTipText("Enter/Remove the Sun as a reference entry");
 TGCheckButton* bmoon=new TGCheckButton(Ssolar,"Moon");
 bmoon->SetToolTipText("Enter/Remove the Moon as a reference entry");
 TGCheckButton* bmercury=new TGCheckButton(Ssolar,"Mercury");
 bmercury->SetToolTipText("Enter/Remove Mercury as a reference entry");
 TGCheckButton* bvenus=new TGCheckButton(Ssolar,"Venus");
 bvenus->SetToolTipText("Enter/Remove Venus as a reference entry");
 TGCheckButton* bearth=new TGCheckButton(Ssolar,"Earth");
 bearth->SetToolTipText("Enter/Remove the Earth as a reference entry");
 TGCheckButton* bmars=new TGCheckButton(Ssolar,"Mars");
 bmars->SetToolTipText("Enter/Remove Mars as a reference entry");
 TGCheckButton* bjupiter=new TGCheckButton(Ssolar,"Jupiter");
 bjupiter->SetToolTipText("Enter/Remove Jupiter as a reference entry");
 TGCheckButton* bsaturn=new TGCheckButton(Ssolar,"Saturn");
 bsaturn->SetToolTipText("Enter/Remove Saturn as a reference entry");
 TGCheckButton* buranus=new TGCheckButton(Ssolar,"Uranus");
 buranus->SetToolTipText("Enter/Remove Uranus as a reference entry");
 TGCheckButton* bneptune=new TGCheckButton(Ssolar,"Neptune");
 bneptune->SetToolTipText("Enter/Remove Neptune as a reference entry");
 solar->AddFrame(Ssolar);
 Ssolar->Show();
 Ssolar->SetButton(1,kFALSE);
 Ssolar->SetButton(2,kFALSE);
 Ssolar->SetButton(3,kFALSE);
 Ssolar->SetButton(4,kFALSE);
 Ssolar->SetButton(5,kFALSE);
 Ssolar->SetButton(6,kFALSE);
 Ssolar->SetButton(7,kFALSE);
 Ssolar->SetButton(8,kFALSE);
 Ssolar->SetButton(9,kFALSE);
 Ssolar->SetButton(10,kFALSE);
 for (Int_t i=0; i<10; i++)
 {
  fMapSolar[i]=kFALSE;
 }
 
 // The Solar system Enter and Remove command buttons
 TGVerticalFrame* comms=new TGVerticalFrame(solar,1,1);
 TGLayoutHints* Lcomms=new TGLayoutHints(kLHintsLeft,10,0,15,0);
 solar->AddFrame(comms,Lcomms); // Command buttons
 
 // The button to Enter the solar system entries
 TGTextButton* enter=new TGTextButton(comms,"Enter");
 enter->SetToolTipText("Enter the selected Solar system objects as reference signals");
 enter->Connect("Clicked()","NcAstrolab",this,"MapEnterSolar()");
 TGLayoutHints* Lenter=new TGLayoutHints(kLHintsCenterX,0,0,10,15);
 comms->AddFrame(enter,Lenter);
 
 // The button to Remove the solar system entries
 TGTextButton* remove=new TGTextButton(comms,"Remove");
 remove->SetToolTipText("Remove the selected Solar system objects from the reference signals");
 remove->Connect("Clicked()","NcAstrolab",this,"MapRemoveSolar()");
 TGLayoutHints* Lremove=new TGLayoutHints(kLHintsCenterX,0,0,0,0);
 comms->AddFrame(remove,Lremove);
}

void NcAstrolab::MapDcoord(Int_t i)
{
 
 TString system[9]={"equ","equ","equ","equ","gal","ecl","hor","icr","loc"};
 TString mode[4]={"J","M","T","B"};
 
 if (i<=9) fMapDcoord=system[i-1];
 
 if (i<=4) fMapDmode=mode[i-1];
}

void NcAstrolab::MapProj(Int_t i)
{
 
 TString s[13]={"ham","ait","mer","ang","cyl","UTh","LTh","GSTh","LSTh","UYh","LYh","GSYh","LSYh"};
 TString sh[13]={"hamh","aith","merh","angh","cylh","UTh","LTh","GSTh","LSTh","UYh","LYh","GSYh","LSYh"};
 if (!fMapDoptions[0] && i<13) fMapProj=s[i-1];
 if (fMapDoptions[0] && i<13) fMapProj=sh[i-1];
 for (Int_t k=0; k<13; k++)
 {
  if (fMapDoptions[0] && fMapProj==s[k]) fMapProj=sh[k];
  if (!fMapDoptions[0] && fMapProj==sh[k]) fMapProj=s[k];
 }
}

void NcAstrolab::MapMerMode(Int_t i)
{
 
 Int_t modes[3]={0,1,-1};
 if (i<=3) fMapMerMode=modes[i-1];
}

void NcAstrolab::MapMerC(const char* text)
{
 
 TString s=text;
 fMapMerC=s.Atof();
}

void NcAstrolab::MapMerUc(Int_t i)
{
 
 TString s[4]={"deg","dms","hms","rad"};
 if (i<=4) fMapMerUc=s[i-1];
}

void NcAstrolab::MapDoptions(Int_t i)
{
 
 if (i>5) return;
 
 if (!fMapDoptions[i-1])
 {
  fMapDoptions[i-1]=1;
 }
 else
 {
  fMapDoptions[i-1]=0;
 }
 if (i==1) MapProj(14); // Set histogram selection
}

void NcAstrolab::MapNmax(const char* text)
{
 
 TString s=text;
 fMapNmax=s.Atoi();
}

void NcAstrolab::MapNdigs(const char* text)
{
 
 TString s=text;
 fMapNdigs=s.Atoi();
}

void NcAstrolab::MapDname(const char* text)
{
 
 fMapDname=text;
}

void NcAstrolab::MapMarkSize(const char* text)
{
 
 TString s=text;
 fMapMarkSize=s.Atof();
}

void NcAstrolab::MapMarkStyle(Int_t i)
{
 
 Int_t styles[17]={8,29,21,22,23,33,34,31,2,5,24,30,25,26,32,27,28};
 
 if (i>17) return;
 
 fMapMarkStyle=styles[i-1];
}

void NcAstrolab::MapMarkColor(Int_t i)
{
 
 Int_t colors[15]={kBlack,kRed,kBlue,kGreen,kYellow,kMagenta,kCyan,kOrange,kViolet,kPink,kAzure,kSpring,kTeal,kGray,kWhite};
 
 if (i>15) return;
 
 fMapMarkColor=colors[i-1];
}

void NcAstrolab::MapMarkType(Int_t i)
{
 
 if (i<=4) fMapMarkType=i-1;
}

void NcAstrolab::MapSolar(Int_t i)
{
 
 if (i>10) return;
 
 if (!fMapSolar[i-1])
 {
  fMapSolar[i-1]=1;
 }
 else
 {
  fMapSolar[i-1]=0;
 }
}

void NcAstrolab::MapEnterSolar()
{
 
 TString names[10]={"Sun","Moon","Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
 
 SetMapTS(); // Get the selected timestamp
 
 fSkyMapPanel->RequestFocus();
 
 for (Int_t i=0; i<10; i++)
 {
  if (fMapSolar[i]) GetSignal(names[i],0,&fMapTS);
 }
 printf("\n *** Selected Solar system object(s) entered *** \n");
}

void NcAstrolab::MapRemoveSolar()
{
 
 TString names[10]={"Sun","Moon","Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
 
 SetMapTS(); // Get the selected timestamp
 
 fSkyMapPanel->RequestFocus();
 
 Int_t nrem=0;
 Int_t nremx=0;
 for (Int_t i=0; i<10; i++)
 {
  if (fMapSolar[i])
  {
   nremx=RemoveSignal(names[i],0,1);
   if (nremx) nrem++;
  }
 }
 
 printf("\n *** Number of Solar system object that have been removed : %-i *** \n",nrem);
}

void NcAstrolab::CommandPanel(TGCompositeFrame* frame)
{
 
 if (!frame) return;
 
 TGGroupFrame* panel=new TGGroupFrame(frame,"Commands",kVerticalFrame);
 panel->SetTitlePos(TGGroupFrame::kCenter);
 frame->AddFrame(panel);
 
 TGTextButton* list=new TGTextButton(panel,"List");
 list->Connect("Clicked()","NcAstrolab",this,"MapList()");
 list->SetToolTipText("List the selected entries");
 TGLayoutHints* Llist=new TGLayoutHints(kLHintsCenterX,0,0,10,10);
 panel->AddFrame(list,Llist);
 
 TGTextButton* map=new TGTextButton(panel,"Map");
 map->Connect("Clicked()","NcAstrolab",this,"MapDraw()");
 map->SetToolTipText("Display the selected entries");
 TGLayoutHints* Lmap=new TGLayoutHints(kLHintsCenterX,0,0,10,10);
 panel->AddFrame(map,Lmap);
 
 TGTextButton* close=new TGTextButton(panel,"Close");
 close->Connect("Clicked()","NcAstrolab",this,"MapClose()");
 close->SetToolTipText("Close this panel window");
 TGLayoutHints* Lclose=new TGLayoutHints(kLHintsCenterX,0,0,10,10);
 panel->AddFrame(close,Lclose);
 
 TGTextButton* exit=new TGTextButton(panel,"Exit");
 exit->Connect("Clicked()","NcAstrolab",this,"MapExit()");
 exit->SetToolTipText("Exit this ROOT session");
 TGLayoutHints* Lexit=new TGLayoutHints(kLHintsCenterX,0,0,10,10);
 panel->AddFrame(exit,Lexit);
}

void NcAstrolab::MapList()
{
 
 SetMapTS(); // Set the skymap timestamp
 
 fSkyMapPanel->RequestFocus();
 
 Int_t type=0;
 if (fMapDoptions[3]) type=1;
 if (fMapDoptions[2] && fMapDoptions[3]) type=-1;
 
 NcTimestamp* ts=&fMapTS; // User selected timestamp
 if (fMapLabTS) ts=0; // To get Lab timestamp notification in listings
 
 Int_t j=0;
 if (fMapDoptions[4]) j=-1; // Individual reference timestamps
 
 printf("\n");
 ListSignals(fMapDcoord,fMapDmode,fMapNdigs,"T",fMapNmax,j,type,ts,fMapDname);
}

void NcAstrolab::MapDraw()
{
 
 SetMapTS(); // Set the skymap timestamp
 
 fSkyMapPanel->RequestFocus();
 
 Int_t type=0;
 if (fMapDoptions[3]) type=1;
 if (fMapDoptions[2] && fMapDoptions[3]) type=-1;
 
 NcTimestamp* ts=&fMapTS; // User selected timestamp
 if (fMapLabTS) ts=0; // To get Lab timestamp notification in listings
 
 Int_t j=0;
 if (fMapDoptions[4]) j=-1; // Individual reference timestamps
 
 SetCentralMeridian(fMapMerMode,fMapMerC,fMapMerUc);
 SetMarkerSize(fMapMarkSize,fMapMarkType);
 SetMarkerStyle(fMapMarkStyle,fMapMarkType);
 SetMarkerColor(fMapMarkColor,fMapMarkType);
 
 DisplaySignals(fMapDcoord,fMapDmode,ts,fMapProj,fMapDoptions[1],fMapNmax,j,type,fMapDname);
}

void NcAstrolab::MapClose()
{
 
 // De-activate all automatic CloseWindow() actions of the system window manager
 // in order to fully control it in this function 
 fSkyMapPanel->DontCallClose();
 
 // To prevent crash when the cursor is still left active in a TextEntry
 fSkyMapPanel->RequestFocus();
 
 // Unmap the display window
 fSkyMapPanel->UnmapWindow();
}

void NcAstrolab::MapExit()
{
 
 fSkyMapPanel->RequestFocus();
 fSkyMapPanel->Cleanup();
 gApplication->Terminate(0);
}

void NcAstrolab::SetMapTS()
{
 
 fMapLabTS=kFALSE;
 Int_t imjd=0;
 Int_t isec=0;
 Int_t ins=0;
 Int_t ips=0;
 
 if (fMapTimeType=="SysClock") // Use the system clock time
 {
  fMapTS.SetSystemTime();
 }
 else if (fMapTimeType=="Lab") // Use the Lab timestamp
 {
  fMapTS.SetMJD(fMJD,fJsec,fJns,fJps);
  fMapLabTS=kTRUE;
 }
 else if (fMapTimeType=="MJD") // Modified Julian Date entry
 {
  Double_t mjd=fMapDateTime.Atof();
  fMapTS.SetMJD(mjd);
 }
 else if (fMapTimeType=="JD") // Julian Date entry
 {
  Double_t jd=fMapDateTime.Atof();
  fMapTS.SetJD(jd);
 }
 else if (fMapTimeType=="TJD") // Truncated Julian Date entry
 {
  Double_t tjd=fMapDateTime.Atof();
  fMapTS.SetTJD(tjd);
 }
 else if (fMapTimeType=="Unix") // Unix time
 {
  Double_t val=fMapDateTime.Atof();
  fMapTS.SetUnixTime(val);
 }
 else
 {
  if (fMapTimeType.Contains("Name")) // Get timestamp of the specified named entry
  {
   NcSignal* sx=0;
   NcTimestamp* tx=0;
   TString name=fMapDateTime;
   sx=GetSignal(name,1);
   if (!sx) sx=GetSignal(name,0);
   if (sx) tx=sx->GetTimestamp();
   if (tx) // Stored entry was found
   {
    tx->GetMJD(imjd,isec,ins);
    ips=tx->GetPs();
    fMapTS.SetMJD(imjd,isec,ins,ips);
   }
   else
   {
    printf("\n *** No stored entry with name %-s found --> Lab TS will be used *** \n",name.Data());
    GetMJD(imjd,isec,ins);
    ips=GetPs();
    fMapTS.SetMJD(imjd,isec,ins,ips);
    fMapLabTS=kTRUE;
   }
    fMapTS.GetDayTimeString("UTC",12,0,&fMapDate,&fMapTime,kFALSE);
  }
  else // Date/Time entry
  {
   fMapDate=fMapDateTime;
   fMapDate.Remove(fMapDateTime.Index("/"),fMapDateTime.Length());
   fMapTime=fMapDateTime;
   fMapTime.Remove(0,fMapDateTime.Index("/")+1);
  }
 
  // Set the timestamp according to the date/time strings
  fMapTS.SetUT(fMapDate,fMapTime,0);
  if (fMapTimeType=="UT1") fMapTS.SetUT(fMapDate,fMapTime,0,"U");
  if (fMapTimeType=="LMT") fMapTS.SetLT(fToffset,fMapDate,fMapTime,0);
  if (fMapTimeType=="GPS" || fMapTimeType=="TAI" || fMapTimeType=="TT")
  {
   fMapTS.SetTAI(fMapTimeType,fMapDate,fMapTime,0,"A",0);
  }
 }
 
 // Show the new timestamp in the textbox
 fMapTS.GetDayTimeString("UTC",3,0,&fMapDate,&fMapTime,kFALSE);
 fMapDateTime=fMapDate;
 fMapDateTime+="/";
 fMapDateTime+=fMapTime;
 fMapTSdatetime->SetText(fMapDateTime);
 
 // Adapt the timestamp type for the updated text window contents
 if (fMapTStimetype) fMapTStimetype->Select(1,kTRUE);
 MapTimeType(1);
}

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