NcAstrolab Class Reference

Virtual lab to provide (astro)physical parameters, treat data and relate observations with astrophysical phenomena. More...

#include "NcAstrolab.h"

Inheritance diagram for NcAstrolab:

Detailed Description

Virtual lab to provide (astro)physical parameters, treat data and relate observations with astrophysical phenomena.

---

Copyright(c) 2007 NCFS/IIHE, All Rights Reserved.                           *
                                                                            *
Authors: The Netherlands Center for Fundamental Studies (NCFS).             *
         The Inter-university Institute for High Energies (IIHE).           *                 
                   Website : http://www.iihe.ac.be                          *
           Contact : Nick van Eijndhoven (nickve.nl@gmail.com)              *
                                                                            *
Contributors are mentioned in the code where appropriate.                   *
                                                                            * 
No part of this software may be used, copied, modified or distributed       *
by any means nor transmitted or translated into machine language for        *
commercial purposes without written permission by the IIHE representative.  *
Permission to use the software strictly for non-commercial purposes         *
is hereby granted without fee, provided that the above copyright notice     *
appears in all copies and that both the copyright notice and this           *
permission notice appear in the supporting documentation.                   *
This software is provided "as is" without express or implied warranty.      *
The authors make no claims that this software is free of error, or is       *
consistent with any particular standard of merchantability, or that it      *
will meet your requirements for any particular application, other than      *
indicated in the corresponding documentation.                               *
This software should not be relied on for solving a problem whose           *
incorrect solution could result in injury to a person or loss of property.  *
If you do use this software in such a manner, it is at your own risk.       *
The authors disclaim all liability for direct or consequential damage       *
resulting from your use of this software.                                   *

---

// Class NcAstrolab
// Virtual lab to provide (astro)physical parameters, treat data and relate observations with astrophysical phenomena
//
// This class is derived from TTask, but the only reason for this
// is to enable this class to serve as a base class for other TTask
// derived classes (e.g. NcEventSelector) without the need for
// multiple virtual inheritance.
// So, this NcAstrolab class itself does not provide any TTask
// related functionality.
//
// The lab can be given a terrestrial location via SetLabPosition()
// using the usual longitude and latitude specifications.
// Since this class is derived from NcTimestamp, a lab can also be
// given a specific timestamp. Together with the terrestrial location
// this provides access to local (sidereal) times etc...
// In addition to the usual astronomical reference frames, a local
// lab reference frame can also be specified via SetLocalFrame().
// Together with the lab's timestamp this uniquely defines all the
// coordinate transformations between the various reference frames.
// These lab characteristics allow space and time correlations of lab
// observations with external (astrophysical) phenomena.
//
// By default, the lab is located at the North Pole using UTC
// and the right handed local reference frame has the following convention :
// X-axis pointing South (=Greenwich)
// Y-axis pointing East
// Z-axis pointing towards Zenith
//
// The location and local reference frame convention of several well
// known experimental sites can be automatically obtained via
// the memberfunction SetExperiment().
//
// Observations are entered as generic signals containing a position,
// reference frame specification and a timestamp (see SetSignal).
// These observations can then be analysed in various reference frames
// via the available GET functions.
//
// Various external (astrophysical) phenomena may be entered as
// so-called reference signals.
// This NcAstrolab class provides facilities (e.g. MatchSignals) to check
// correlations of the stored measurements with these reference signals.
// The memberfunction SetTimeScramble provides a facility to scramble
// the timestamp of an observation or time differences with reference signals.
// The memberfunction SetPositionScramble provides a facility to scramble
// the location of an observation or angular differences with reference signals.
// These facilities will enable a background c.q. blind analysis in studying
// correlations with external (astrophysical) phenomena.
//
// The member function sequence InitDataNames(), SetDataNames() and LoadInputData()
// provides a generic facility to load both observations and reference signals
// from ROOT data files in Tree format.
// This provides a convenient way to load e.g. experimental observations or (GCN) catalog data.
//
// This NcAstrolab class also provides a facility to model c.q. perform the
// analysis of transient phenomena by means of (stacked) time series observations.
// It reflects the observation of neutrinos based on gamma/GW burst alerts, but the
// procedure may of course be used for any kind of messenger particles.
// For a worked out example, please refer to the macro "burst-model.cc"
// in the folder "/ncfs/physics/macros".
//
// By default different random sequences are ensured for different NcAstrolab instances,
// even with identical stored measurements and reference signals.  
// In case the user wants to control the random sequence (e.g. to obtain reproducible results),
// the randomiser has to be explicitly initialised via the member function SetRandomiser().
// 
// Also graphical facilities (e.g. DisplaySignals) are available to
// provide skymaps in various projections.
// A Graphical User Interface (GUI) is available via the memberfunction SkyMapPanel(),
// which facilitates several functionalities in a user friendly graphical environment.
// 
// Coding example :
// ----------------
// gSystem->Load("ncfspack");
//
// NcAstrolab lab("IceCube","The South Pole Neutrino Observatory");
// lab.SetLabPosition(0,-90,"deg"); // South Pole
//
// // Right handed Amanda/IceCube local frame has Y-North, X-East and Z-Zenith
// lab.SetLocalFrame(90,90,90,180,0,0);
//
// // Note : The above lab initialisation could also have been performed as follows :
// // NcAstrolab lab;
// // lab.SetExperiment("IceCube"); // Set more precise IceCube location and orientation
//
// // Print laboratory parameters
// lab.Data(1,"dms");
//
// // Enter some measurements (e.g. observed events) to be investigated
// NcTimestamp ts;
// ts.SetUT("30-07-1989","08:14:23.74",0);
// lab.SetSignal(1,-18.2,"deg",87.53,"deg","loc",&ts,-1,"T","Event9081",1);
// ts.Add(0,1,87326);
// lab.SetSignal(1,23.8,"deg",208.65,"deg","loc",&ts,-1,"T","Event10372",1);
//
// // Enter some reference signals
// Float_t alpha=194818.0;
// Float_t delta=84400.;
// lab.SetSignal(1,alpha,"hms",delta,"dms","equ",0,-1,"B","Altair");
// alpha=124900.0;
// delta=272400.;
// lab.SetSignal(1,alpha,"hms",delta,"dms","equ",0,-1,"B","NGP");
// alpha=64508.917;
// delta=-164258.02;
// lab.SetSignal(1,alpha,"hms",delta,"dms","equ",0,-1,"J","Sirius");
// alpha=23149.08;
// delta=891550.8;
// lab.SetSignal(1,alpha,"hms",delta,"dms","equ",0,-1,"J","Polaris");
// alpha=43600.;
// delta=163100.;
// lab.SetSignal(1,alpha,"hms",delta,"dms","equ",0,-1,"J","Aldebaran");
// lab.SetSignal(1,182948.53,"hms",380228.45,"dms","equ",0,-1,"J","LyrA");
// lab.SetSignal(1,0,"deg",-90,"deg","gal",0,-1,"M","SGP");
// // Mimic a GRB 5 seconds before the occurrence of Event10372
// ts.Add(0,-5,0);
// lab.SetSignal(1,327.531,"deg",-35.8903,"deg","gal",&ts,-1,"T","GRB890730");
// ts.Add(0,5,0); // Restore the time stamp
//
// // List all stored objects
// cout << endl;
// lab.ListSignals("equ","J",5,"M",-1);
//
// // Search for space and time matches between the measurements and the reference signals
// // within a cone of 20 degrees and a time window of [-60,60] seconds
// NcDevice matches;
// lab.MatchSignals(matches,20,"deg",60,"s");
// matches.Data();
// 
// // Get the minimal encountered angular and time difference
// // (for a more detailed example please refer to the docs of MatchSignals)
// Double_t da=0; // Angular difference
// Double_t dt=0; // Time difference
// Int_t ia=0;    // "Hit" index of the pair with the minimal angular difference 
// Int_t it=0;    // "Hit" index of the pair with the minimal time difference 
// da=matches.GetSignal(1);
// dt=matches.GetSignal(2);
// ia=matches.GetSignal(3);
// it=matches.GetSignal(4);
//
// cout << " Minimal differences damin (deg) : " << da << " dtmin (s) : " << dt << endl;
//
// // The full information for the pair with the minimal time difference
// NcSignal* sx=matches.GetHit(it);
// if (sx) sx->Data();
//
// // Display all stored objects in a skymap (Hammer projection)
// lab.DisplaySignals("equ","J",0,"ham",1);
//
//--- Author: Nick van Eijndhoven 15-mar-2007 Utrecht University
//- Modified: Nick van Eijndhoven, IIHE-VUB Brussel, September 30, 2025  22:30Z

Definition at line 46 of file NcAstrolab.h.

Public Member Functions
	NcAstrolab (const char *name="User", const char *title="Virtual Lab for general use")
	NcAstrolab (const NcAstrolab &t)
virtual	~NcAstrolab ()
virtual TObject *	Clone (const char *name="") const
Double_t	ConvertAngle (Double_t a, TString in, TString out) const
void	Data (Int_t mode=1, TString u="deg", Bool_t utc=kTRUE)
void	DisplaySignal (TString frame, TString mode, NcTimestamp *ts, Int_t j=-1, TString proj="ham", Int_t clr=0, TString name="")
void	DisplaySignal (TString frame, TString mode, NcTimestamp *ts, TString name, TString proj="ham", Int_t clr=0, Int_t type=0)
void	DisplaySignals (TString frame, TString mode, NcTimestamp *ts, TString proj="ham", Int_t clr=0, Int_t nmax=-1, Int_t j=-1, Int_t type=-1, TString name="*")
void	GenBurstGCNdata (Int_t n, TString name="GRB", Bool_t scale=kFALSE)
void	GenBurstSignals ()
void	GeoToHeliocentric (Double_t &R, Double_t &B, Double_t &L, NcTimestamp *ts, TString Bu="deg", TString Lu="deg")
TF1	GetBackgroundRatePDF (Double_t Noff, Double_t Toff, Double_t bmax=-1, Double_t prec=709)
Double_t	GetBurstBackgroundEnergy (Double_t Emin=-1, Double_t Emax=-1) const
void	GetBurstBayesianPsiStatistics (TString type, Double_t nr=-1, Int_t ncut=10, Int_t ndt=2, Bool_t zcor=kFALSE, Int_t freq=0)
TH1 *	GetBurstBayesianSignalRate (Double_t p, Double_t &rlow, Double_t &rup, Int_t n=1000)
void	GetBurstChi2Statistics (TString type, Int_t ndt=2, Bool_t zcor=kFALSE)
Double_t	GetBurstLiMaSignificance () const
NcDevice *	GetBurstParameters ()
Double_t	GetBurstRecoAngres (Double_t Emin=-1, Double_t Emax=-1, Double_t Amin=0, Double_t Amax=999) const
Double_t	GetBurstSignalEnergy (Double_t Emin=-1, Double_t Emax=-1) const
Double_t	GetComovingDistance (Double_t z, TString u="Mpc") const
TH1F	GetCountsHistogram (TF1 &spec, Int_t nbins, Double_t xmin, Double_t xmax, Int_t mode, TString s="") const
TH1F	GetCountsHistogram (TH1 &hin, Int_t mode, TString s="", TF1 *fscale=0) const
Double_t	GetCredibleInterval (TF1 pdf, Double_t p, Double_t &xlow, Double_t &xup, Int_t n=1000)
Double_t	GetCredibleInterval (TF1 pdf, Double_t p, Float_t &xlow, Float_t &xup, Int_t n=1000)
Double_t	GetCredibleInterval (TH1 *his, Double_t p, Double_t &xlow, Double_t &xup)
Double_t	GetCredibleInterval (TH1 *his, Double_t p, Float_t &xlow, Float_t &xup)
TH1F	GetCumulHistogram (TF1 *f, TString name, Int_t nbins, Double_t xmin, Double_t xmax, TString mode="F") const
TH1F	GetCumulHistogram (TH1 *h, TString name, TString mode="F") const
Double_t	GetDifference (Int_t jref, TString au, Double_t &dt, TString tu, Int_t mode=1, Int_t *ia=0, Int_t *it=0)
Int_t	GetDifference (NcTimestamp &t, Int_t &days, Int_t &sec, Int_t &ns, Int_t &ps, TString type="UT")
Double_t	GetDifference (NcTimestamp &t, TString u, Int_t mode=1, TString type="UT")
Int_t	GetDifference (NcTimestamp *t, Int_t &days, Int_t &sec, Int_t &ns, Int_t &ps, TString type="UT")
Double_t	GetDifference (NcTimestamp *t, TString u, Int_t mode=1, TString type="UT")
Double_t	GetDifference (TString name, TString au, Double_t &dt, TString tu, Int_t mode=1)
TH1F	GetDifHistogram (TH1 *hin, Int_t mode, TString s="", TF1 *f=0) const
TH1F	GetDxHistogram (TH1 *hx, Int_t nc, Double_t dxbin=-1, Double_t dxmin=-1, Double_t dxmax=-1, Int_t mode=1, Double_t fact=1)
TString	GetExperiment () const
Double_t	GetHourAngle (TString mode, NcTimestamp *ts, Int_t jref=0, Int_t type=0)
Double_t	GetHubbleParameter (Double_t z, TString u="Mpc") const
Double_t	GetInteractionProbability (Double_t x, Double_t lambda) const
Double_t	GetInteractionProbability (Double_t x, Double_t sigma, Double_t rho, Int_t mode) const
Int_t	GetLabDetectorId () const
NcPosition	GetLabPosition () const
void	GetLabPosition (Double_t &l, Double_t &b, TString u="deg") const
Double_t	GetLabTimeOffset () const
Double_t	GetLAST ()
Double_t	GetLAST (Double_t offset)
Double_t	GetLightTravelDistance (Double_t z, TString u="Mpc") const
Double_t	GetLightTravelTime (Double_t z) const
Double_t	GetLMST ()
Double_t	GetLMST (Double_t offset)
void	GetLocalFrame (Float_t arr[6])
TH1F	GetLogHistogram (TH1 *hin, Int_t mode, TString s="") const
Double_t	GetLT ()
Double_t	GetLT (Double_t offset)
Double_t	GetLuminosityDistance (Double_t z, TString u="Mpc") const
Double_t	GetMaxDt () const
Double_t	GetMeanFreePath (Double_t sigma, Double_t rho, Int_t mode) const
Double_t	GetNeutrinoAngle (Double_t E, TString u, Int_t mode, TF1 *f=0)
Double_t	GetNeutrinoXsection (Int_t mode, Int_t type, Double_t egev, Double_t xscale=1, Double_t *eprimgev=0, Double_t *alpha=0) const
Int_t	GetNRefSignals (Int_t mode=0) const
Int_t	GetNsignals (Int_t type, Int_t mode=0) const
Double_t	GetNuclearMass (Int_t Z, Int_t N, Int_t mode=1) const
Double_t	GetPhysicalDistance (Double_t z, TString u="Mpc", Int_t t=1) const
Double_t	GetPhysicalParameter (TString name) const
Int_t	GetPositionScramble (Double_t *dmin=0, Double_t *dmax=0, TF1 *df=0, Double_t *thmin=0, Double_t *thmax=0, TF1 *thf=0, Double_t *phimin=0, Double_t *phimax=0, TF1 *phif=0)
Double_t	GetProperDistance (Double_t z, TString u="Mpc", Int_t t=1) const
Double_t	GetRadiationLength (Double_t Z, Double_t A, Double_t rho=-1) const
NcRandom *	GetRandomiser (Int_t &iseed, Int_t &cnt1, Int_t &cnt2) const
Double_t	GetSeparation (TString name1, TString name2, TString au, Double_t *dt=0, TString tu="s", Int_t mode=1, Double_t *diftheta=0, Double_t *difphi=0)
Double_t	GetShieldingThickness (Double_t prob, Double_t lambda) const
Double_t	GetShieldingThickness (Double_t prob, Double_t sigma, Double_t rho, Int_t mode) const
NcSignal *	GetSignal (Double_t &d, Double_t &a, TString au, Double_t &b, TString bu, TString frame, NcTimestamp *ts, Int_t jref, TString mode="T", Int_t type=0)
NcSignal *	GetSignal (Double_t &d, Double_t &a, TString au, Double_t &b, TString bu, TString frame, NcTimestamp *ts, TString name, TString mode="T", Int_t type=0)
NcSignal *	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=0)
NcSignal *	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=0)
NcSignal *	GetSignal (Int_t jref=0, Int_t type=0)
NcSignal *	GetSignal (TString name, Int_t type=0, NcTimestamp *ts=0)
Int_t	GetSignalIndex (NcSignal *s, Int_t type)
Int_t	GetSignalIndex (TString name, Int_t type=0)
TF1	GetSignalRatePDF (Double_t Non, Double_t Ton, Double_t Noff, Double_t Toff, Double_t Ra=1, Double_t Re=1, Double_t smax=-1, Double_t bmax=-1, Double_t prec=709)
Double_t	GetSolidAngle (Double_t thetamin, Double_t thetamax, TString tu, Double_t phimin, Double_t phimax, TString pu) const
Double_t	GetSourceAttributes (NcSignal *s, Float_t *z=0, Float_t *T90=0)
Double_t	GetSurvivalProbability (Double_t x, Double_t lambda) const
Double_t	GetSurvivalProbability (Double_t x, Double_t sigma, Double_t rho, Int_t mode) const
Double_t	GetTargetThickness (Double_t prob, Double_t lambda) const
Double_t	GetTargetThickness (Double_t prob, Double_t sigma, Double_t rho, Int_t mode) const
Int_t	GetTimeScramble (Double_t *tmin=0, Double_t *tmax=0, TF1 *frndm=0)
Double_t	GetUpperLimit (TF1 pdf, Double_t p)
Double_t	GetUpperLimit (TH1 *pdf, Double_t p)
void	HelioToGeocentric (Double_t &R, Double_t &B, Double_t &L, NcTimestamp *ts, TString Bu="deg", TString Lu="deg")
void	InitDataNames (Int_t dir, TString frame, TString mode="J")
Double_t	KolmogorovTest (TString mode, TH1 *h1, TH1 *h2=0, TF1 *pdf=0, Double_t nr=1000, TH1F *ksh=0, Int_t ncut=0, Double_t *nrx=0, Int_t mark=1)
void	ListBurstHistograms () const
void	ListBurstParameters () const
void	ListDataNames ()
void	ListSignals (TString frame, TString mode, Int_t ndig=1, TString emode="T", Int_t nmax=10, Int_t j=-1, Int_t type=-1, NcTimestamp *ts=0, TString name="*")
void	LoadInputData (Bool_t src, TString file, TString tree, Int_t date1=0, Int_t date2=0, Int_t nmax=-1, TString type="-")
void	MakeBurstEnergydist (Int_t mode, Double_t alpha, Double_t Emin, Double_t Emax, Int_t nbins=1000)
void	MakeBurstEnergydist (Int_t mode, TF1 &spec, Double_t Emin, Double_t Emax, Int_t nbins=1000)
void	MakeBurstEnergydist (Int_t mode, TString file, TString tree, TString name1, TString name2, TString u, Double_t Emin, Double_t Emax, Int_t nb=1000)
void	MakeBurstRecoAngresdist (TString file, TString tree, TString name1, TString name2, TString ua, TString name3, TString ud, Double_t Emin, Double_t Emax, Int_t nbe=100, Int_t nba=1000)
void	MakeBurstSigmaPosdist (TString file, TString tree, TString name, TString u, Int_t nb=900, Float_t xmin=0, Float_t xmax=90)
void	MakeBurstT90dist (TString file, TString tree, TString name, Int_t nb=50, Float_t xmin=-5, Float_t xmax=5)
void	MakeBurstZdist (TString file, TString tree, TString name, Int_t nb=200, Float_t zmin=0, Float_t zmax=20)
void	MapCinfo (Int_t)
void	MapClose ()
void	MapDateTime (const char *text)
void	MapDcoord (Int_t i)
void	MapDname (const char *text)
void	MapDoptions (Int_t i)
void	MapDraw ()
void	MapEa (const char *text)
void	MapEb (const char *text)
void	MapEcoord (Int_t i)
void	MapEname (const char *text)
void	MapEnter ()
void	MapEnterSolar ()
void	MapEtype (Int_t i)
void	MapExit ()
void	MapExperiment (Int_t i)
void	MapIname (const char *text)
void	MapInfo ()
void	MapLabLframeEnter ()
void	MapLabTS ()
void	MapList ()
void	MapLocb (const char *text)
void	MapLocEnter ()
void	MapLocId (const char *text)
void	MapLocl (const char *text)
void	MapMarkColor (Int_t i)
void	MapMarkSize (const char *text)
void	MapMarkStyle (Int_t i)
void	MapMarkType (Int_t i)
void	MapMerC (const char *text)
void	MapMerMode (Int_t i)
void	MapMerUc (Int_t i)
void	MapNdigs (const char *text)
void	MapNmax (const char *text)
void	MapProj (Int_t i)
void	MapRemove ()
void	MapRemoveSolar ()
void	MapSolar (Int_t i)
void	MapTimeType (Int_t i)
void	MapTinfo (Int_t)
void	MapUa (Int_t i)
void	MapUb (Int_t i)
void	MapUinfo (Int_t)
void	MapUloc (Int_t i)
void	MatchBurstData (NcDevice &matches, Int_t i1=1, Int_t i2=0, Int_t itype=0, Int_t j1=1, Int_t j2=0, Int_t jtype=1)
void	MatchBurstData (NcDevice &matches, TString name, Int_t itype=0, Int_t j1=1, Int_t j2=0, Int_t jtype=1)
TArrayI *	MatchRefSignal (Double_t da, TString au, Double_t dt, TString tu, Int_t mode=1)
void	MatchSignals (NcDevice &matches, Double_t da, TString au, Double_t dt, TString tu, Int_t mode=1, Int_t i1=1, Int_t i2=0, Int_t itype=0, Int_t j1=1, Int_t j2=0, Int_t jtype=1)
void	MatchSignals (NcDevice &matches, TString name, Double_t da, TString au, Double_t dt, TString tu, Int_t mode=1, Int_t itype=0, Int_t j1=1, Int_t j2=0, Int_t jtype=1)
void	PrintAngle (Double_t a, TString in, TString out, Int_t ndig=1, Bool_t align=kFALSE) const
void	PrintSignal (TString frame, TString mode, NcTimestamp *ts, Int_t ndig, Int_t jref=0, TString emode="T", Int_t type=0, Bool_t align=kFALSE)
void	PrintSignal (TString frame, TString mode, NcTimestamp *ts, Int_t ndig, TString name, TString emode="T", Int_t type=0, Bool_t align=kFALSE)
void	RandomPosition (Nc3Vector &v, Double_t thetamin, Double_t thetamax, Double_t phimin, Double_t phimax)
Int_t	RemoveRefSignal (Int_t j, Int_t compress)
Int_t	RemoveRefSignal (TString name, Int_t compress)
Int_t	RemoveSignal (Int_t j, Int_t type, Int_t compress)
Int_t	RemoveSignal (TString name, Int_t type, Int_t compress)
Int_t	RemoveSignals (TString name, Int_t type, Int_t compress)
void	SetBurstParameter (TString name, Double_t value)
void	SetCentralMeridian (Int_t mode=0, Double_t phi=0, TString u="deg")
void	SetDataNames (TString obsname, TString varname, TString units="1", TString func="none")
void	SetExperiment (TString name, Int_t id=0)
void	SetLabPosition (Double_t l, Double_t b, TString u="deg")
void	SetLabPosition (Nc3Vector &r)
void	SetLabTimeOffset (Double_t dt)
void	SetLocalFrame (Double_t t1, Double_t p1, Double_t t2, Double_t p2, Double_t t3, Double_t p3)
void	SetLT (Double_t dt, Int_t y, Int_t d, Int_t s, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Double_t s, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, TString time, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, TString date, TString time, Int_t mode, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Int_t y, Int_t d, Int_t s, Int_t ns=0, Int_t ps=0)
void	SetLT (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Double_t s)
void	SetLT (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns=0, Int_t ps=0)
void	SetLT (Int_t y, Int_t m, Int_t d, TString time)
void	SetLT (TString date, TString time, Int_t mode)
void	SetMarkerColor (Int_t color, Int_t type)
void	SetMarkerSize (Float_t size, Int_t type)
void	SetMarkerStyle (Int_t style, Int_t type)
void	SetMaxDt (Double_t s)
void	SetPhysicalParameter (TString name, Double_t value)
void	SetPositionScramble (Int_t mode, Double_t dmin, Double_t dmax, TF1 *df=0, Double_t thmin=0, Double_t thmax=0, TF1 *thf=0, Double_t phimin=0, Double_t phimax=0, TF1 *phif=0)
void	SetRandomiser (Int_t iseed, Int_t cnt1=0, Int_t cnt2=0, NcTimestamp *ts=0)
NcSignal *	SetSignal (Double_t d, Double_t a, TString au, Double_t b, TString bu, TString frame, NcTimestamp *ts, Int_t jref, TString mode="T", TString name="", Int_t type=0)
NcSignal *	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=0)
Int_t	SetSourceAttributes (NcSignal *s, Double_t sigmapos, TString u, Double_t z=-999, Double_t T90=-999)
void	SetTimeScramble (Int_t mode, Double_t tmin, Double_t tmax, TF1 *frndm=0)
void	ShiftPosition (Nc3Vector &v, Double_t angle)
virtual void	SkyMapPanel ()
void	SmearPosition (Nc3Vector &v, Double_t sigma)
void	WriteBurstHistograms (TString filename)
Public Member Functions inherited from NcTimestamp
	NcTimestamp ()
	NcTimestamp (const NcTimestamp &t)
	NcTimestamp (TTimeStamp &t)
virtual	~NcTimestamp ()
void	Add (Double_t hours)
void	Add (Int_t d, Int_t s, Int_t ns, Int_t ps=0)
void	AddSec (Double_t seconds)
Double_t	Almanac (Double_t *dpsi=0, Double_t *deps=0, Double_t *eps=0, Double_t *dl=0, TString name="", Double_t *el=0, Double_t *eb=0, Double_t *dr=0, Double_t *value=0, Int_t j=0)
void	Convert (Double_t date, Int_t &days, Int_t &secs, Int_t &ns) const
void	Convert (Double_t h, Int_t &hh, Int_t &mm, Double_t &ss) const
void	Convert (Double_t h, Int_t &hh, Int_t &mm, Int_t &ss, Int_t &ns, Int_t &ps) const
Double_t	Convert (Int_t days, Int_t secs, Int_t ns) const
Double_t	Convert (Int_t hh, Int_t mm, Double_t ss) const
Double_t	Convert (Int_t hh, Int_t mm, Int_t ss, Int_t ns, Int_t ps) const
void	Date (Int_t mode=3, Double_t offset=0)
Double_t	GetBE ()
Double_t	GetBE (Double_t date, TString mode="jd") const
TString	GetDayTimeString (TString mode, Int_t ndig=0, Double_t offset=0, TString *date=0, TString *time=0, Bool_t full=kTRUE)
Int_t	GetDifference (NcTimestamp &t, Int_t &days, Int_t &sec, Int_t &ns, Int_t &ps, TString type="UT")
Double_t	GetDifference (NcTimestamp &t, TString u, Int_t mode=1, TString type="UT")
Int_t	GetDifference (NcTimestamp *t, Int_t &days, Int_t &sec, Int_t &ns, Int_t &ps, TString type="UT")
Double_t	GetDifference (NcTimestamp *t, TString u, Int_t mode=1, TString type="UT")
Double_t	GetEpoch (TString mode)
Double_t	GetGAST ()
Double_t	GetGMST ()
void	GetGMST (Int_t &hh, Int_t &mm, Int_t &ss, Int_t &ns, Int_t &ps)
TTree *	GetIERSdatabase () const
Double_t	GetJD ()
Double_t	GetJD (Double_t e, TString mode="J") const
void	GetJD (Int_t &jd, Int_t &sec, Int_t &ns)
Double_t	GetJD (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns) const
Double_t	GetJE ()
Double_t	GetJE (Double_t date, TString mode="jd") const
Double_t	GetLAST (Double_t offset)
Double_t	GetLAT (Double_t offset)
Double_t	GetLMST (Double_t offset)
Double_t	GetLT (Double_t offset)
Double_t	GetMJD ()
Double_t	GetMJD (Double_t e, TString mode="J") const
void	GetMJD (Int_t &mjd, Int_t &sec, Int_t &ns)
Double_t	GetMJD (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns) const
Int_t	GetNs () const
Int_t	GetPs () const
Double_t	GetTAI (Bool_t tmjd=kTRUE)
Int_t	GetTAI (Int_t &d, Int_t &sec, Int_t &ns, Int_t &ps, Bool_t tmjd=kTRUE)
Int_t	GetTAI (Int_t &hh, Int_t &mm, Int_t &ss, Int_t &ns, Int_t &ps, TString type="TAI")
Double_t	GetTJD ()
Double_t	GetTJD (Double_t e, TString mode="J") const
void	GetTJD (Int_t &tjd, Int_t &sec, Int_t &ns)
Double_t	GetTJD (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns) const
Double_t	GetUnixTime ()
Double_t	GetUT ()
void	GetUT (Int_t &hh, Int_t &mm, Int_t &ss, Int_t &ns, Int_t &ps)
Int_t	GetUTCparameters (Int_t &leap, Double_t &dut) const
Int_t	GetUTCparameters (Int_t mjd, Int_t &leap, Double_t &dut) const
Bool_t	IsUT1 () const
TTree *	LoadUTCparameterFiles (TString leapfile="$(NCFS)/IERS/leap.txt", TString dutfile="$(NCFS)/IERS/dut.txt")
void	PrintTime (Double_t h, Int_t ndig=1) const
void	SetEpoch (Double_t e, TString mode, TString utc="U", Int_t leap=0, Double_t dut=0)
Int_t	SetGPS (Int_t w, Int_t dow, Int_t sod, Int_t ns, Int_t ps, TString utc, Int_t leap, Double_t dut=0, Int_t icycle=0)
Int_t	SetGPS (Int_t w, Int_t sow, Int_t ns, Int_t ps, TString utc, Int_t leap, Double_t dut=0, Int_t icycle=0)
void	SetJD (Double_t jd, TString utc="U", Int_t leap=0, Double_t dut=0)
void	SetJD (Int_t jd, Int_t sec, Int_t ns, Int_t ps=0, TString utc="U", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t d, Int_t s, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Double_t s, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, Int_t y, Int_t m, Int_t d, TString time, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetLT (Double_t dt, TString date, TString time, Int_t mode, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetMJD (Double_t mjd, TString utc="U", Int_t leap=0, Double_t dut=0)
void	SetMJD (Int_t mjd, Int_t sec, Int_t ns, Int_t ps=0, TString utc="U", Int_t leap=0, Double_t dut=0)
void	SetNs (Int_t ns)
void	SetPs (Int_t ps)
void	SetSystemTime ()
Int_t	SetTAI (Double_t tai, TString utc, Int_t leap, Double_t dut=0, Bool_t tmjd=kFALSE)
Int_t	SetTAI (Int_t d, Int_t sec, Int_t ns, Int_t ps, TString utc, Int_t leap, Double_t dut=0, Bool_t tmjd=kFALSE)
Int_t	SetTAI (TString type, TString date, TString time, Int_t mode, TString utc, Int_t leap, Double_t dut=0)
void	SetTJD (Double_t tjd, TString utc="U", Int_t leap=0, Double_t dut=0)
void	SetTJD (Int_t tjd, Int_t sec, Int_t ns, Int_t ps=0, TString utc="U", Int_t leap=0, Double_t dut=0)
Int_t	SetUnixTime (Double_t sec, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetUT (Int_t y, Int_t d, Int_t s, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetUT (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Double_t s, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetUT (Int_t y, Int_t m, Int_t d, Int_t hh, Int_t mm, Int_t ss, Int_t ns=0, Int_t ps=0, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetUT (Int_t y, Int_t m, Int_t d, TString time, TString utc="A", Int_t leap=0, Double_t dut=0)
void	SetUT (TString date, TString time, Int_t mode, TString utc="A", Int_t leap=0, Double_t dut=0)

Protected Member Functions
void	BurstCompensate (Int_t &nmugrb)
virtual void	CommandPanel (TGCompositeFrame *frame)
virtual void	EntriesPanel (TGCompositeFrame *frame)
Double_t	GetBackgroundRateProb (Double_t *vars, Double_t *pars)
void	GetBurstDtDistributions (Int_t ndt, TH1F &hisdtOn, TF1 &pdfdtOn, TH1F &hisdtOff, TF1 &pdfdtOff, Bool_t zcor)
TH1 *	GetBurstSigmaPosdist (TString name, TString type)
TH1 *	GetBurstT90dist (TString name, TString type)
TH1 *	GetBurstZdist (TString name, TString type)
Double_t	GetSeparation (Int_t i, Int_t j, TString au, Double_t &dt, TString tu, Int_t mode, Int_t bkgpatch, Double_t *diftheta=0, Double_t *difphi=0)
NcSignal *	GetSignal (Nc3Vector &r, TString frame, TString mode, NcTimestamp *ts, Int_t jref, Int_t type)
Double_t	GetSignalRateProb (Double_t *vars, Double_t *pars)
virtual void	InfoPanel (TGCompositeFrame *frame)
void	InitBurstHistograms (Int_t mode)
virtual void	LabLocalFramePanel (TGCompositeFrame *frame)
virtual void	LabLocationPanel (TGCompositeFrame *frame)
void	MakeBurstDataStats (Int_t mode, Int_t nmugrb=0)
virtual void	MapListOptionsPanel (TGCompositeFrame *frame)
void	Nutate (Nc3Vector &r, NcTimestamp *ts)
void	Precess (Nc3Vector &r, NcTimestamp *ts1, NcTimestamp *ts2)
void	Project (Double_t l, Double_t b, TString proj, Double_t &x, Double_t &y)
void	ProjectAitoff (Double_t l, Double_t b, Double_t &x, Double_t &y)
void	ProjectCylindrical (Double_t l, Double_t b, Double_t &x, Double_t &y)
void	ProjectHammer (Double_t l, Double_t b, Double_t &x, Double_t &y)
void	ProjectMercator (Double_t l, Double_t b, Double_t &x, Double_t &y)
void	SetBmatrix ()
void	SetEmatrix (NcTimestamp *ts)
void	SetGmatrix (TString mode)
void	SetHmatrix (NcTimestamp *ts)
void	SetMapTS ()
void	SetNmatrix (NcTimestamp *ts)
void	SetPmatrix (NcTimestamp *ts)
NcSignal *	SetSignal (Nc3Vector *r, TString frame, TString mode, NcTimestamp *ts, Int_t jref, TString name, Int_t type)
Int_t	SetSolarSystem (TString name, NcTimestamp *ts, Int_t type=0)
virtual void	TimestampPanel (TGCompositeFrame *frame)
Protected Member Functions inherited from NcTimestamp
Int_t	SetUTCparameters (TString utc, Int_t leap, Double_t dut)

Protected Attributes
Double_t	fAlphaEM
Double_t	fAmu
Double_t	fAu
Double_t	fAxes [6]
TRotMatrix	fB
	! The frame bias matrix for conversion of ICRS to J2000 coordinates
Int_t	fBias
	! Initialisation flag for fB values (0=uninitialised 1=initialised)
Double_t	fBoltz
TObjArray	fBurstHistos
NcSample	fBurstOffMatch
NcSample	fBurstOffReco
NcSample	fBurstOnMatch
NcSample	fBurstOnReco
NcDevice *	fBurstParameters
NcSample	fBurstSignal
NcSample	fBurstSigReco
TCanvas *	fCanvas
	! The canvas for the skymap
Int_t	fDataDir
TString	fDataFrame
TString	fDataMode
NcObjMatrix	fDataNames
TF1 *	fDscfunc
Double_t	fDscmax
Double_t	fDscmin
TRotMatrix	fE
	! Matrix for conversion of equatorial to ecliptic coordinates
TString	fExperiment
Double_t	fFermi
TRotMatrix	fG
	! Matrix for conversion of equatorial to galactic coordinates
Int_t	fGal
	! Type indicator for fG values (0=uninitialised 1=B1950 2=J2000)
Double_t	fGammaW
Double_t	fGammaZ
Double_t	fGn
TRotMatrix	fH
	! Matrix for conversion of equatorial to horizontal coordinates
Double_t	fHbar
Double_t	fHbarc
Double_t	fHbarc2
TH2 *	fHist [2]
	! Temp. histograms for the sky display
Double_t	fHubble
TArrayI *	fIndices
	! Storage indices of the matching reference signals
TRotMatrix	fL
Int_t	fLabId
NcPosition	fLabPos
TString	fMapCinfo
	! The GUI selected info category
TString	fMapDate
	! The GUI entered date
TString	fMapDateTime
	! The GUI entered datetime
TString	fMapDcoord
	! The GUI selected coordinate system for the Map/List
TString	fMapDmode
	! The GUI selected coordinate system mode for the Map/List
TString	fMapDname
	! The GUI entered name pattern for entries to be shown in the Map/List
Bool_t	fMapDoptions [5]
	! The GUI Map/List options (histo, clr, ref, meas, refTS)
Double_t	fMapEa
	! The GUI entered a coordinate of an entry
Double_t	fMapEb
	! The GUI entered b coordinate of an entry
TString	fMapEcoord
	! The GUI entered coordinate system of the entry
TString	fMapEmode
	! The GUI entered coordinate system mode of the entry
TString	fMapEname
	! The GUI entered name of the entry
Int_t	fMapEtype
	! The GUI entered entry type
TString	fMapEua
	! The GUI entered angular units of a
TString	fMapEub
	! The GUI entered angular units of b
TString	fMapIname
	! The GUI selected entry name for the info
TGComboBox *	fMapLabE
	! The GUI Lab experiment site selection box
TString	fMapLabExpName
	! The GUI entered Lab experimental site
Int_t	fMapLabId
	! The GUI entered Lab detector Id
TGNumberEntryField *	fMapLabLBI [3]
	! The GUI number entries for the Lab location specification
TGNumberEntryField *	fMapLabLframe [6]
	! The GUI number entries for the local frame specification
Double_t	fMapLabLocB
	! The GUI entered Lab latitude
Double_t	fMapLabLocL
	! The GUI entered Lab longitude
TString	fMapLabLocU
	! The GUI entered Lab location angular units
Bool_t	fMapLabTS
	! The GUI selection to use the Lab timestamp for the List/Map
TGComboBox *	fMapLabU
	! The GUI Lab location angular unit selection box
Int_t	fMapMarkColor
	! The GUI selected marker color for the Map
Double_t	fMapMarkSize
	! The GUI entered marker size for the Map
Int_t	fMapMarkStyle
	! The GUI selected marker style for the Map
Int_t	fMapMarkType
	! The GUI selected entry type to apply the marker attributes on
Double_t	fMapMerC
	! The GUI entered central meridian location for the Map
Int_t	fMapMerMode
	! The GUI selected meridian orientation for the Map
TString	fMapMerUc
	! The GUI selected angular units for the central meridian location
Int_t	fMapNdigs
	! The GUI selected number of digits for the List output
Int_t	fMapNmax
	! The GUI selected max. number of signals of each type to Map/List
TString	fMapProj
	! The GUI selected projection for the Map
Bool_t	fMapSolar [10]
	! The GUI selection of solar system objects
TString	fMapTime
	! The GUI entered time
TString	fMapTimeType
	! The GUI entered time type
Int_t	fMapTinfo
	! The GUI selected mode for the timestamp info
NcTimestamp	fMapTS
	! The GUI entered timestamp to be used for the List/Map
TGTextEntry *	fMapTSdatetime
	! The GUI TS date/time specification
TGComboBox *	fMapTStimetype
	! The GUI TS time type selection box
TString	fMapUinfo
	! The GUI selected angular units for the Lab info
Int_t	fMarkerColor [4]
TObjArray *	fMarkers
	! Temp. array to hold the markers for the signal display
Float_t	fMarkerSize [4]
Int_t	fMarkerStyle [4]
Double_t	fMaxDt
Double_t	fMe
Double_t	fMeridian
	! Central meridian (in rad) for the sky display
Double_t	fMmu
Double_t	fMn
Double_t	fMp
Double_t	fMtau
Double_t	fMW
Double_t	fMZ
TRotMatrix	fN
	! Matrix for nutation correction
ULong64_t	fNen [2]
Double_t	fNewton
TF1 *	fNuAngle
Double_t	fOmegaB
Double_t	fOmegaC
Double_t	fOmegaL
Double_t	fOmegaM
Double_t	fOmegaR
TRotMatrix	fP
	! Matrix for precession correction
Double_t	fPc
TF1 *	fPhiscfunc
Double_t	fPhiscmax
Double_t	fPhiscmin
Double_t	fPlanck
TString	fProj
	! Projection which is currently in use
Double_t	fQe
NcRandom *	fRan
TObjArray *	fRefs
Int_t	fRscmode
TObjArray *	fSigs
TGMainFrame *	fSkyMapPanel
	! The main frame for the SkyMapPanel GUI
Int_t	fSolUpdate
Double_t	fSpeedC
TF1 *	fThetascfunc
Double_t	fThetascmax
Double_t	fThetascmin
Double_t	fToffset
TF1 *	fTscfunc
Double_t	fTscmax
Double_t	fTscmin
Int_t	fTscmode
Int_t	fUsMeridian
Protected Attributes inherited from NcTimestamp
Double_t	fDut
Int_t	fJns
Int_t	fJps
Int_t	fJsec
Int_t	fLeap
Int_t	fMJD
Int_t	fTmjd
Int_t	fTns
Int_t	fTps
Int_t	fTsec
Int_t	fUtc
TTree *	fUTCdata

Constructor & Destructor Documentation

NcAstrolab() [1/2]

NcAstrolab::NcAstrolab	(	const char *	name = "User",
		const char *	title = "Virtual Lab for general use" )

// Default constructor.

Definition at line 194 of file NcAstrolab.cxx.

~NcAstrolab()

NcAstrolab::~NcAstrolab ( )

virtual

// Destructor to delete all allocated memory.

Definition at line 368 of file NcAstrolab.cxx.

NcAstrolab() [2/2]

NcAstrolab::NcAstrolab

(

const NcAstrolab &

t

)

// Copy constructor.

Definition at line 451 of file NcAstrolab.cxx.

Member Function Documentation

BurstCompensate()

void NcAstrolab::BurstCompensate ( Int_t & nmugrb )

protected

// Compensate statistical underfluctuation in the number of transient burst muons.

Definition at line 15938 of file NcAstrolab.cxx.

Clone()

TObject * NcAstrolab::Clone ( const char * name = "" ) const

virtual

// Make a deep copy of the current object and provide the pointer to the copy.
// This memberfunction enables automatic creation of new objects of the
// correct type depending on the object type, a feature which may be very useful
// for containers when adding objects in case the container owns the objects.

Reimplemented in NcEventSelector.

Definition at line 19305 of file NcAstrolab.cxx.

CommandPanel()

void NcAstrolab::CommandPanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the GUI panel with the various command buttons.

Definition at line 19079 of file NcAstrolab.cxx.

ConvertAngle()

Double_t NcAstrolab::ConvertAngle	(	Double_t	a,
		TString	in,
		TString	out ) const

// Conversion of various angular formats.
//
// The input argument "a" denotes the angle to be converted. 
// The string arguments "in" and "out" specify the angular I/O formats.
//
// in = "rad" : input angle provided in radians
//      "deg" : input angle provided in degrees
//      "dms" : input angle provided in dddmmss.sss
//      "hms" : input angle provided in hhmmss.sss
//      "hrs" : input angle provided in fractional hours
//
// out = "rad" : output angle provided in radians
//       "deg" : output angle provided in degrees
//       "dms" : output angle provided in dddmmss.sss
//       "hms" : output angle provided in hhmmss.sss
//       "hrs" : output angle provided in fractional hours

Definition at line 4448 of file NcAstrolab.cxx.

Data()

void NcAstrolab::Data	(	Int_t	mode = 1,
		TString	u = "deg",
		Bool_t	utc = kTRUE )

// Provide lab information.
//
// "mode" indicates the mode of the timestamp info (see NcTimestamp::Date).
//
// The string argument "u" allows to choose between different angular units
// in case e.g. a spherical frame is selected.
// u = "rad" : angles provided in radians
//     "deg" : angles provided in degrees
//     "dms" : angles provided in ddd:mm:ss.sss
//     "hms" : angles provided in hh:mm:ss.sss
//
// The boolean argument "utc" allows to add UTC and TAI related date/time
// information in case this is available.
// utc = kTRUE  --> Add the UTC and TAI related information
//       kFALSE --> Do not add the UTC and TAI related information
//
// The defaults are mode=1, u="deg" and utc=kTRUE.

Definition at line 537 of file NcAstrolab.cxx.

DisplaySignal() [1/2]

void NcAstrolab::DisplaySignal	(	TString	frame,
		TString	mode,
		NcTimestamp *	ts,
		Int_t	j = -1,
		TString	proj = "ham",
		Int_t	clr = 0,
		TString	name = "" )

// Display a stored signal in a user specified coordinate projection
// at the specific timestamp ts.
//
// The input parameter "j" allows display of measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with 
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// j >0 --> Display of the reference signal at the j-th position (j=1 is first)
//   <0 --> Display of the measurement at the j-th position
//   =0 --> Display of the first measurement (only kept for backward compatibility)
//
// The user is advised not to use the obsolete "j=0" functionality anymore.
//
// Default value is j=-1 for backward compatibility.
//
// Measurements are indicated as blue dots.
// Reference signals are indicated as red stars.
// The Galactic Center is indicated as a black cross.
// The attributes of the marker symbols may be tailored via the member functions
// SetMarkerSize(), SetMarkerStyle() and SetMarkerColor().
//
// In case a non-empty string for the input parameter "name" is provided, this name will
// appear in the title text of the display. In this way the user can indicate the name
// of the object that is displayed.
//
// In case no stored signal was available or one of the input arguments was
// invalid, no display is produced.
//
// Note : In case ts=0 the actual recorded timestamp of the signal will be taken.
//        If such a recorded timestamp is absent, the current timestamp of the lab is used.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" specifies either "mean", "true" or "epoch" values for the equatorial (a,d) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The input parameter "proj" allows the user to specify the desired projection.
// The available projection modes are :
//
// cyl  : Cylindrical equirectangular (straight b vs. l) projection plotted with colored markers
// cylh : Cylindrical equirectangular (straight b vs. l) projection plotted in a 2-D histogram
// ham  : Hammer equal area projection plotted with colored markers
// hamh : Hammer equal area projection plotted in a 2-D histogram
// ait  : Aitoff projection plotted with colored markers
// aith : Aitoff projection plotted in a 2-D histogram
// mer  : Mercator projection plotted with colored markers
// merh : Mercator projection plotted in a 2-D histogram
// ang  : Straight sin(b) vs. l plot with colored markers
// angh : Straight sin(b) vs. l plot in a 2-D histogram
// UTh  : Day view (0-24 hours) of b vs. Universal Time
// LTh  : Day view (0-24 hours) of b vs. Local Time
// GSTh : Day view (0-24 hours) of b vs. Greenwich Siderial Time
// LSTh : Day view (0-24 hours) of b vs. Local Siderial Time
// UYh  : Year view of b vs. day of the year at the Universal Time of the specified timestamp
// LYh  : Year view of b vs. day of the year at the Local Time of the specified timestamp
// GSYh : Year view of b vs. day of the year at the Greenwich Siderial Time of the specified timestamp
// LSYh : Year view of b vs. day of the year at the Local Siderial Time of the specified timestamp
//
// Notes :
// -------
// 1) The ang(h) plot allows for easy identification of an isotropic distribution.
// 2) For the projections "GSTh", "LSTh", "GSYh" and "LSYh", the input argument "mode"
//    also determines whether they show the Mean (mode="M") or Apparent (mode="T") Sidereal Time. 
//
// The input argument "clr" allows to clear (1) the display before drawing or not (0).
//
// The default values are : j=0, proj="ham", clr=0 and name="".
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 6125 of file NcAstrolab.cxx.

DisplaySignal() [2/2]

void NcAstrolab::DisplaySignal	(	TString	frame,
		TString	mode,
		NcTimestamp *	ts,
		TString	name,
		TString	proj = "ham",
		Int_t	clr = 0,
		Int_t	type = 0 )

// Display the stored signal according to "type" with the specified name in a user specified
// coordinate projection at the specific timestamp ts.
//
// The input parameter "type" allows to specify either measurements or reference signals.
//
// type = 0 --> Display the corresponding reference signal
//        1 --> Display the corresponding measurement
//
// Measurements are indicated as blue dots.
// Reference signals are indicated as red stars.
// The Galactic Center is indicated as a black cross.
// The attributes of the marker symbols may be tailored via the member functions
// SetMarkerSize(), SetMarkerStyle() and SetMarkerColor().
//
// Note : In case ts=0 the actual recorded timestamp of the signal will be taken.
//        If such a recorded timestamp is absent, the current timestamp of the lab is used.
//
// In case no such stored signal was available or one of the input arguments was
// invalid, no display is produced.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" specifies either "mean", "true" or "epoch" values for the equatorial (a,d) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The input parameter "proj" allows the user to specify the desired projection.
// The available projection modes are :
//
// cyl  : Cylindrical equirectangular (straight b vs. l) projection plotted with colored markers
// cylh : Cylindrical equirectangular (straight b vs. l) projection plotted in a 2-D histogram
// ham  : Hammer equal area projection plotted with colored markers
// hamh : Hammer equal area projection plotted in a 2-D histogram
// ait  : Aitoff projection plotted with colored markers
// aith : Aitoff projection plotted in a 2-D histogram
// mer  : Mercator projection plotted with colored markers
// merh : Mercator projection plotted in a 2-D histogram
// ang  : Straight sin(b) vs. l plot with colored markers
// angh : Straight sin(b) vs. l plot in a 2-D histogram
// UTh  : Day view (0-24 hours) of b vs. Universal Time
// LTh  : Day view (0-24 hours) of b vs. Local Time
// GSTh : Day view (0-24 hours) of b vs. Greenwich Siderial Time
// LSTh : Day view (0-24 hours) of b vs. Local Siderial Time
// UYh  : Year view of b vs. day of the year at the Universal Time of the specified timestamp
// LYh  : Year view of b vs. day of the year at the Local Time of the specified timestamp
// GSYh : Year view of b vs. day of the year at the Greenwich Siderial Time of the specified timestamp
// LSYh : Year view of b vs. day of the year at the Local Siderial Time of the specified timestamp
//
// Notes :
// -------
// 1) In case the name specifies a solar system object which was not yet stored according to "type",
//    the corresponding signal will be created and stored with the specified timestamp.
//    All geocentric name specifications for solar system objects as indicated in the
//    docs of NcTimestamp::Almanac() are supported.
// 2) The ang(h) plot allows for easy identification of an isotropic distribution.
// 3) For the projections "GSTh", "LSTh", "GSYh" and "LSYh", the input argument "mode"
//    also determines whether they show the Mean (mode="M") or Apparent (mode="T") Sidereal Time. 
//
// The input argument "clr" allows to clear (1) the display before drawing or not (0).
//
// The default values are : proj="ham", clr=0 and type=0.

Definition at line 6996 of file NcAstrolab.cxx.

DisplaySignals()

void NcAstrolab::DisplaySignals	(	TString	frame,
		TString	mode,
		NcTimestamp *	ts,
		TString	proj = "ham",
		Int_t	clr = 0,
		Int_t	nmax = -1,
		Int_t	j = -1,
		Int_t	type = -1,
		TString	name = "*" )

// Display of stored signals in a user specified coordinate projection at the specific timestamp,
// if their name matches the provided name pattern "name", where name="*" means all.
//
// All measurements are displayed according to the timestamp of their actual stored recording,
// which may be a scrambled timestamp according to the invokation of the memberfunction SetTimeScramble().
//
// For reference signals the actual timestamp of the j-th (j=1 is first) measurement is used.
// In case j=0 the provided timestamp "ts" is used for all the reference signals.
// For j<0 the timestamp of the actual recording of each reference signal will be used.
//
// In case a timestamp is not present for a certain signal, the provided "ts" is used instead.
// Note : ts=0 corresponds to the current timestamp of the lab.
//
// Measurements are indicated as blue dots.
// Reference signals are indicated as red stars.
// The Galactic Center is indicated as a black cross.
// The attributes of the marker symbols may be tailored via the member functions
// SetMarkerSize(), SetMarkerStyle() and SetMarkerColor().
//
// In case no corresponding stored signal is available or one of the input arguments is
// invalid, no display is produced.
//
// type = 0 --> Display the data of stored reference signals
//        1 --> Display the data of stored measured signals
//      < 0 --> Display the data of both measured and reference signals  
//
// The argument "nmax" specifies the maximum number of measured c.q. reference signals
// that will be listed. When nmax<0 all stored measured c.q. reference signals are listed.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" specifies either "mean", "true" or "epoch" values for the equatorial (a,d) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The input parameter "proj" allows the user to specify the desired projection.
// The available projection modes are :
//
// cyl  : Cylindrical equirectangular (straight b vs. l) projection plotted with colored markers
// cylh : Cylindrical equirectangular (straight b vs. l) projection plotted in a 2-D histogram
// ham  : Hammer equal area projection plotted with colored markers
// hamh : Hammer equal area projection plotted in a 2-D histogram
// ait  : Aitoff projection plotted with colored markers
// aith : Aitoff projection plotted in a 2-D histogram
// mer  : Mercator projection plotted with colored markers
// merh : Mercator projection plotted in a 2-D histogram
// ang  : Straight sin(b) vs. l plot with colored markers
// angh : Straight sin(b) vs. l plot in a 2-D histogram
// UTh  : Day view (0-24 hours) of b vs. Universal Time
// LTh  : Day view (0-24 hours) of b vs. Local Time
// GSTh : Day view (0-24 hours) of b vs. Greenwich Siderial Time
// LSTh : Day view (0-24 hours) of b vs. Local Siderial Time
// UYh  : Year view of b vs. day of the year at the Universal Time of the specified timestamp
// LYh  : Year view of b vs. day of the year at the Local Time of the specified timestamp
// GSYh : Year view of b vs. day of the year at the Greenwich Siderial Time of the specified timestamp
// LSYh : Year view of b vs. day of the year at the Local Siderial Time of the specified timestamp
//
// Notes :
// -------
// 1) The ang(h) plot allows for easy identification of an isotropic distribution.
// 2) For the projections "GSTh", "LSTh", "GSYh" and "LSYh", the input argument "mode"
//    also determines whether they show the Mean (mode="M") or Apparent (mode="T") Sidereal Time. 
//
// The input argument "clr" allows to clear (1) the display before drawing or not (0).
//
// The default values are : proj="ham", clr=0, nmax=-1, j=-1, type=-1 and name="*".

Definition at line 7103 of file NcAstrolab.cxx.

EntriesPanel()

void NcAstrolab::EntriesPanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the GUI panel to enter c.q. remove data entries.

Definition at line 18309 of file NcAstrolab.cxx.

GenBurstGCNdata()

void NcAstrolab::GenBurstGCNdata	(	Int_t	n,
		TString	name = "GRB",
		Bool_t	scale = kFALSE )

// Generate fictative burst GCN data for "n" bursts of (alert) type "name",
// where "name" can be "GRB", "GW", "IC", ....
// Data will be generated according to the parameters as specified
// by the user via prior invokation of the memberfunction SetBurstParameter().
//
// Note :
// ------
// The input parameter "scale" indicates whether "n" represents the actual number
// of bursts in the user defined (RA,DEC) acceptance (scale=kFALSE) or the full sky
// number of bursts (scale=kTRUE).
//
// The default values are name="GRB" and scale=kFALSE.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 12355 of file NcAstrolab.cxx.

GenBurstSignals()

void NcAstrolab::GenBurstSignals

(

)

// Generate detector signals from transient bursts and (atmospheric) background.
// Data will be generated according to the parameters as specified
// by the user via prior invokation of the memberfunction SetBurstParameter().
//
// Since both the signal and background events are generated according to the
// parameters specified by the user, no additional matching of the (fictative)
// observations with the source positions is needed.
// As such, after the invokation of this GenBurstSignals(), the user may directly
// invoke various statistical evaluations like for instance GetBurstLiMaSignificance(),
// GetBurstBayesianSignalRate() etc...  
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 13616 of file NcAstrolab.cxx.

GeoToHeliocentric()

void NcAstrolab::GeoToHeliocentric	(	Double_t &	R,
		Double_t &	B,
		Double_t &	L,
		NcTimestamp *	ts,
		TString	Bu = "deg",
		TString	Lu = "deg" )

// Convert Geocentric ecliptic coordinates into Heliocentric ones at the provided timestamp.
// The algorithm used here is the one outlined in Ch. 33 of the book by Jean Meeus,
// "Astronomical Algorithms" (2nd edition of August 2009).
// In view of the accuracy of the current algorithm, the effects of light-time
// and aberration are not taken into account here.
//
// Input arguments :
// -----------------
// R  : Geocentric distance of the object in Astronomical Units (AU)
// B  : Geocentric ecliptic latitude
// L  : Geocentric ecliptic longitude
// ts : Timestamp of the (R,B,L) observation (0=The current NcAstrolab timestamp)
// Bu : Angular units of B (see below)
// Lu : Angular units of L (see below)
//
// Angular units indicator :
// -------------------------
// "rad" : input angle provided in radians
// "deg" : input angle provided in degrees
// "dms" : input angle provided in dddmmss.sss
// "hms" : input angle provided in hhmmss.sss
// "hrs" : input angle provided in fractional hours
//
// After the conversion, R, B and L will be the Heliocentric values.
//
// Note : For objects far outside the Solar System, the Geocentric and Heliocentric
//        coordinates are basically identical.
//
// The default values are Bu="deg" and Lu="deg".

Definition at line 2500 of file NcAstrolab.cxx.

GetBackgroundRatePDF()

TF1 NcAstrolab::GetBackgroundRatePDF	(	Double_t	Noff,
		Double_t	Toff,
		Double_t	bmax = -1,
		Double_t	prec = 709 )

// Provide the posterior Bayesian PDF for a background rate "b"
// given the specified background ("off source") observations.
//
// Details of the method can be found in the publication Astrop. Phys. 50-52 (2013) 57.
// The actual code is implemented in the internal memberfunction GetBackgroundRateProb().
//
// The input arguments :
// ---------------------
// Noff : The number of observed background ("off source") events.
// Toff : The ("off source") exposure time in seconds.
// bmax : The maximal background event rate in Hz.
//        If bmax<0 this parameter is automatically set to 100*Noff/Toff
//        to obtain good prior coverage as indicated below.
// prec : Cut off value to limit exponential expressions to exp(|prec|) or exp(-|prec|)
//        to prevent overflow or underflow.
//
// Default values : bmax=-1 and prec=709.
//
// The returned PDF is p(b|Noff,Toff,I), where "I" indicates the prior information.
//
// The prior p(b|I) for the background rate has been taken as a uniform prior within the range [0,bmax].
// The parameter "bmax" may be provided as a result from previous studies, reflecting prior information
// to be used in the Bayesian evaluation.
// If not provided (or as a negative value) the parameter "bmax" is set automatically
// to provide good prior coverage.

Definition at line 10042 of file NcAstrolab.cxx.

GetBackgroundRateProb()

Double_t NcAstrolab::GetBackgroundRateProb ( Double_t * vars, Double_t * pars )

protected

// Provide the posterior Bayesian probability for a certain background rate "b"
// given some specified background (c.q. "off source") observations.
//
// *** This is an internal interface memberfunction used by GetBackgroundRatePDF() ***
//
// Details of the method can be found in the publication Astrop. Phys. 50-52 (2013) 57.
//
// The input arguments :
// ---------------------
// vars[0] (b)    : The background rate (in Hz) for which the posterior probability will be evaluated.
// pars[0] (Noff) : The number of observed background (c.q. "off source") events.
// pars[1] (Toff) : The background (c.q. "off source") exposure time in seconds.
// pars[2] (bmax) : The maximum background event rate in Hz.
//                  If bmax<0 this parameter is automatically set to 100*Noff/Toff
//                  to obtain good prior coverage as indicated below.
// pars[3] (prec) : Cut off value to limit exponential expressions to exp(|prec|) or exp(-|prec|)
//                  to prevent overflow or underflow.
//
// Default values : bmax=-1 and prec=709.
//
// The returned value is p(b|Noff,Toff,I), where "I" indicates the prior information.
//
// The prior p(b|I) for the background rate has been taken as a uniform prior within the range [0,bmax].
// The parameter "bmax" may be provided as a result from previous studies, reflecting prior information
// to be used in the Bayesian evaluation.
// If not provided (or as a negative value) the parameter "bmax" is set automatically
// to provide good prior coverage.

Definition at line 9865 of file NcAstrolab.cxx.

GetBurstBackgroundEnergy()

Double_t NcAstrolab::GetBurstBackgroundEnergy	(	Double_t	Emin = -1,
		Double_t	Emax = -1 ) const

// Provide the energy in the interval [Emin,Emax] GeV for backgound events
// from the user provided energy spectrum as produced by MakeBurstBkgEdist().
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// If Emin<=0 the lower boundary of the provided spectrum will be used as Emin. 
// If Emax<=0 the upper boundary of the provided spectrum will be used as Emax.
//
// In case of inconsistent data the value -1 is returned.
//
// The default values are Emin=-1 and Emax=-1.

Definition at line 13414 of file NcAstrolab.cxx.

GetBurstBayesianPsiStatistics()

void NcAstrolab::GetBurstBayesianPsiStatistics	(	TString	type,
		Double_t	nr = -1,
		Int_t	ncut = 10,
		Int_t	ndt = 2,
		Bool_t	zcor = kFALSE,
		Int_t	freq = 0 )

// Provide the transient burst Bayesian Psi statistics for the (stacked) distributions of the
// observed arrival times and opening angles w.r.t. the corresponding bursts.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Consider a hypothesis B_m representing a counting experiment with m different
// possible outcomes and which is completely defined by the probabilities
// of the various outcomes (and the requirement that the sum of all these
// probabilities equals 1).
// In mathematical terms such a hypothesis belongs to the Bernoulli class B_m. 
//
// The Psi value of n trials of B_m provides (in dB scale) the amount of support
// that the data can maximally give to any Bernoulli class hypothesis different
// from the currently specified B_m.
//
// To be specific : Psi=-10*log[p(D|B_m I)]
//
// where p(D|B_m I) represents the likelihood of the data D under the condition
// that B_m (given some prior information I) is true.
//
// In our current situation, the hypotheses B_m (i.e. Probability Distribution Functions)
// for the various observed distributions are known and "m" just represents the number
// of bins, and "n" represents the number of entries of the corresponding histogram.
// As such, the Psi value (psi0) of the actual observation can be determined.
//
// Further mathematical details can be found in the publication
// N. van Eijndhoven, Astropart. Phys. 28 (2008) 540 (astro-ph/0702029).
//
// This memberfunction may also provide the statistical P-value (i.e. the fraction of
// recorded psi values with psi>=psi0) for the actually observed psi value (psi0)
// based on "nr" repetitions of the counting experiment corresponding to B_m
// with "n" independent random trials.
//
// Input arguments :
// -----------------
// type : "time"   --> Provide statistics for the observed arrival times.
//                     This will investigate the deviation from a uniform background time spectrum.
//        "BBtime" --> Provide statistics for the Bayesian blocks corresponding to the observed arrival times.
//                     This will investigate the deviation from a uniform event rate.
//        "BBrat"  --> Provide statistics for the normalized On-source/Off-source ratio of the Bayesian blocks
//                     corresponding to the observed arrival times.
//                     This will investigate the relative deviation in event rate.
//        "angle"  --> Provide statistics for the observed opening angles.
//                     This will investigate the deviation from a isotropic background angular spectrum.
//        "cosa"   --> Provide statistics for the cosine of the observed opening angles.
//                     This will investigate the deviation from a uniform background cos(angle) spectrum.
//        "dt"     --> Provide statistics for the time intervals between the observed arrival times.
//                     This will investigate the deviation from dt spectrum expected from Poisson statistics.
// nr   : (Maximum) number of randomised configurations for psi P-value determination.
//        nr<0 implies that no psi P-values will be determined (saves CPU time).
//        nr=0 implies the allowed maximum of 1e19 randomisations.
// ncut : Number of obtained randomised psi entries above the actual observed psi value
//        at which randomisations will be terminated (to save CPU time).
//        ncut=0 implies no early termination.
// ndt  : The step count to arrive at the required consecutive entry to perform the dt statistics.
//        Specifying "ndt=1" will provide the statistics of dt intervals between each consecutive event,
//        i.e. time intervals between the events (1,2), (2,3), (3,4) etc.
//        Specifying "ndt=2" will provide the statistics of dt intervals between every 2nd consecutive event,
//        i.e. time intervals between the events (1,3), (2,4), (3,5) etc.
// zcor : Use redshift corrected arrival times (kTRUE) or not (kFALSE)
// freq : Use frequentist's approximation (1) or exact Bayesian expression (0) for psi.
//
// The default values are nr=-1, ncut=10, ndt=2, zcor=kFALSE and freq=0.

Definition at line 16388 of file NcAstrolab.cxx.

GetBurstBayesianSignalRate()

TH1 * NcAstrolab::GetBurstBayesianSignalRate	(	Double_t	p,
		Double_t &	rlow,
		Double_t &	rup,
		Int_t	n = 1000 )

// Provide the transient burst Bayesian signal rate and the lower and upper bounds of the
// Bayesian "p%" credible interval [rlow,rup] around the mode of the signal PDF.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Input arguments :
// -----------------
// p    : The percentage of the PDF to be covered by the credible interval around the mode.
//        So for a Gaussian PDF, p=68.3 will result in the [mean-sigma,mean+sigma] 68.3% credible interval.
// rlow : The variable for the return of the lower bound of the credible interval. 
// rup  : The variable for the return of the upper bound of the credible interval. 
// n    : The precision on the result, expressed as 1/n.
//
// By default n=1000 which implies that the accuracy of the result is better than 0.1%.
// Note that very large values of "n" may result in a rather long computation time.
//
// The return argument is the histogram for the Bayesian signal rate PDF.
//
// In case of inconsistent data all returned values are 0.

Definition at line 16133 of file NcAstrolab.cxx.

GetBurstChi2Statistics()

void NcAstrolab::GetBurstChi2Statistics	(	TString	type,
		Int_t	ndt = 2,
		Bool_t	zcor = kFALSE )

// Provide the transient burst Chi-squared statistics for the (stacked) distributions
// of the observed arrival times and opening angles w.r.t. the corresponding bursts.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Input arguments :
// -----------------
// type : "time"   --> Provide statistics for the observed arrival times
//                     This will investigate the deviation from a uniform background time spectrum 
//        "BBtime" --> Provide statistics for the Bayesian blocks corresponding to the observed arrival times
//                     This will investigate the deviation from a uniform event rate
//        "BBrat"  --> Provide statistics for the normalized On-source/Off-source ratio of the Bayesian blocks
//                     corresponding to the observed arrival times.
//                     This will investigate the relative deviation in event rate.
//        "angle"  --> Provide statistics for the observed opening angles
//                     This will investigate the deviation from a isotropic background angular spectrum 
//        "cosa"   --> Provide statistics for the cosine of the observed opening angles
//                     This will investigate the deviation from a uniform background cos(angle) spectrum 
//        "dt"     --> Provide statistics for the time intervals between the observed arrival times
//                     This will investigate the deviation from dt spectrum expected from Poisson statistics
// ndt  : The step count to arrive at the required consecutive entry to perform the dt statistics.
//        Specifying "ndt=1" will provide the statistics of dt intervals between each consecutive event,
//        i.e. time intervals between the events (1,2), (2,3), (3,4) etc.
//        Specifying "ndt=2" will provide the statistics of dt intervals between every 2nd consecutive event,
//        i.e. time intervals between the events (1,3), (2,4), (3,5) etc.
// zcor : Use redshift corrected arrival times (kTRUE) or not (kFALSE)
//
// The default values are ndt=2 and zcor=kFALSE.

Definition at line 17085 of file NcAstrolab.cxx.

GetBurstDtDistributions()

void NcAstrolab::GetBurstDtDistributions ( Int_t ndt, TH1F & hisdtOn, TF1 & pdfdtOn, TH1F & hisdtOff, TF1 & pdfdtOff, Bool_t zcor )

protected

// Internal member function to provide the Dt distributions from the Dt NcSamples
//
// Function arguments :
// --------------------
// ndt      : The step count to arrive at the required consecutive entry to produce the dt distributions.
//            Specifying "ndt=1" will provide the distributions of dt intervals between each consecutive event,
//            i.e. time intervals between the events (1,2), (2,3), (3,4) etc.
//            Specifying "ndt=2" will provide the distributions of dt intervals between every 2nd consecutive event,
//            i.e. time intervals between the events (1,3), (2,4), (3,5) etc.
// hisdtOn  : The resulting histogram of observed dt intervals from the on source data  
// pdfdtOn  : The Poisson dt pdf corresponding to the observed event rate from the on source data  
// hisdtOff : The resulting histogram of observed dt intervals from the off source data  
// pdfdtOff : The Poisson dt pdf corresponding to the observed event rate from the off source data
// zcor     : Use redshift corrected arrival times (kTRUE) or not (kFALSE)

Definition at line 17329 of file NcAstrolab.cxx.

GetBurstLiMaSignificance()

Double_t NcAstrolab::GetBurstLiMaSignificance

(

)

const

// Provide the transient burst Li-Ma signal significance in terms of the amount of
// standard deviations w.r.t. the "on source" and "off source" observations.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// In case of inconsistent data the value 0 is returned.

Definition at line 16329 of file NcAstrolab.cxx.

GetBurstParameters()

NcDevice * NcAstrolab::GetBurstParameters

(

)

// Provide a link to the device containing all transient burst parameter settings.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 11644 of file NcAstrolab.cxx.

GetBurstRecoAngres()

Double_t NcAstrolab::GetBurstRecoAngres	(	Double_t	Emin = -1,
		Double_t	Emax = -1,
		Double_t	Amin = 0,
		Double_t	Amax = 999 ) const

// Provide the reconstruction angle resolution (in degrees) for the energy interval [Emin,Emax] GeV.
// Depending on the burst parameter setting "Recoangle", the returned value is either constant
// (i.e. the value of the burst parameter "Angresfix") or determined from the user provided distribution
// as produced by MakeBurstRecoAngresdist().
// In case the user has requested the reconstruction angle resolution to be drawn randomly
// from the distribution, the returned value will be within the interval [Amin,Amax] degrees.
//
// Note : In case no distribution is available, the constant value of "Angresfix" is returned.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// If Emin<=0 the lower boundary of the provided spectrum will be used as Emin. 
// If Emax<=0 the upper boundary of the provided spectrum will be used as Emax.
//
// In case of inconsistent data the value -1 is returned.
//
// The default values are Emin=-1, Emax=-1, Amin=0 and Amax=999.

Definition at line 13485 of file NcAstrolab.cxx.

GetBurstSigmaPosdist()

TH1 * NcAstrolab::GetBurstSigmaPosdist ( TString name, TString type )

protected

// Internal member function to provide the archival c.q. fitted 1-sigma burst position uncertainty distribution.
// The input argument "name" serves to identify the calling function in the printout.
// The input argument "type" serves to identify the source class for which a fit has to be provided.
// Currently only a fit for GRB is available.

Definition at line 12857 of file NcAstrolab.cxx.

GetBurstSignalEnergy()

Double_t NcAstrolab::GetBurstSignalEnergy	(	Double_t	Emin = -1,
		Double_t	Emax = -1 ) const

// Provide the energy in the interval [Emin,Emax] GeV for a Burst signal 
// from the user provided energy spectrum as produced by MakeBurstEdist().
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// If Emin<=0 the lower boundary of the provided spectrum will be used as Emin. 
// If Emax<=0 the upper boundary of the provided spectrum will be used as Emax.
//
// In case of inconsistent data the value -1 is returned.
//
// The default values are Emin=-1 and Emax=-1.

Definition at line 13343 of file NcAstrolab.cxx.

GetBurstT90dist()

TH1 * NcAstrolab::GetBurstT90dist ( TString name, TString type )

protected

// Internal member function to provide the archival c.q. fitted burst T90 distribution.
// The input argument "name" serves to identify the calling function in the printout.
// The input argument "type" serves to identify the source class for which a fit has to be provided.
// Currently only a fit for GRB is available.

Definition at line 12718 of file NcAstrolab.cxx.

GetBurstZdist()

TH1 * NcAstrolab::GetBurstZdist ( TString name, TString type )

protected

// Internal member function to provide the archival c.q. fitted burst redshift distribution.
// The input argument "name" serves to identify the calling function in the printout.
// The input argument "type" serves to identify the source class for which a fit has to be provided.
// Currently only a fit for GRB is available.

Definition at line 12591 of file NcAstrolab.cxx.

GetComovingDistance()

Double_t NcAstrolab::GetComovingDistance	(	Double_t	z,
		TString	u = "Mpc" ) const

// Provide the comoving coordinate distance of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The comoving coordinate distance is constant in time and has in principle
// an arbitrary normalization.
// We adopt here the commonly used normalization that the cosmic expansion factor a(t)
// equals 1 at the current time.
// This implies that the comoving coordinate distance is equal to the physical (or proper)
// distance at the time of the observation of a signal from an object with redshift z.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The input argument "u" allows specification of the required distance units,
// with the following options:
//
// u = "Gpc" (distance in Giga parsec)
//     "Mpc" (distance in Mega parsec)
//     "pc"  (distance in parsec)
//     "ly"  (distance in light years)
//     "km"  (distance in kilometers)
//     "m"   (distance in meters)
//     "cm"  (distance in centimeters)
//
// The default value is u="Mpc" for backward compatibility.
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 7840 of file NcAstrolab.cxx.

GetCountsHistogram() [1/2]

TH1F NcAstrolab::GetCountsHistogram	(	TF1 &	spec,
		Int_t	nbins,
		Double_t	xmin,
		Double_t	xmax,
		Int_t	mode,
		TString	s = "" ) const

// Construct the counts (N) vs. x histogram from a 1D input function describing the differential spectrum dN/dx.
// Such a returned histogram allows an easy way to for instance obtain a primary particle distribution N(E)
// to be used as input for cosmic ray event generators based on a predicted differential power spectrum dN/dE.
//
// Input arguments :
// -----------------
// spec  : The function to describe the dN/dx spectrum
// nbins : Number of bins for the produced histogram
// xmin  : Minimal x value of the produced histogram
// xmax  : Maximum x value of the produced histogram
// mode  : 0 ==> Histogram X-axis represents the x value
//         1 ==> Histogram X-axis represents the Log10(x) value
//         2 ==> Histogram X-axis represents the Ln(x) value
// s     : Character string for the title and axes labels of the returned histogram.
//         Example : s="Energy distribution;^{10}Log(Energy) in GeV;Counts".
//         If string s is not provided the labels will be constructed from the
//         labels of the input function "spec".
//
// Returned object : The 1-D histogram (TH1F) containing the expected counts N vs. x.
//
// By default s="".

Definition at line 9570 of file NcAstrolab.cxx.

GetCountsHistogram() [2/2]

TH1F NcAstrolab::GetCountsHistogram	(	TH1 &	hin,
		Int_t	mode,
		TString	s = "",
		TF1 *	fscale = 0 ) const

// Construct the counts (N) vs. x histogram from a 1D input histogram describing a differential distribution dN/dx.
// Such a returned histogram allows an easy way to for instance obtain a primary particle distribution N(E)
// to be used as input for cosmic ray event generators based on a predicted differential power spectrum dN/dE.
//
// Input arguments :
// -----------------
// hin    : The input histogram describing the fscale(x)*dN/dx distribution
// mode   : 0 ==> Histogram X-axis represents the x value
//          1 ==> Histogram X-axis represents the Log10(x) value
//          2 ==> Histogram X-axis represents the Ln(x) value
// s      : Character string for the title and axes labels of the returned histogram.
//          Example : s="Energy distribution;^{10}Log(Energy) in GeV;Counts".
//          If string s is not provided the labels will be constructed from the
//          labels of the input histogram "hin".
// fscale : (Optional) scaling function that was used for the distribution in "hin".
//          For example : In case "hin" contained E^2*dN/dE vs. E, than the user
//          should specifiy "fscale" as the function "pow(x,2)" so that this scaling
//          can be compensated for in constructing the N(E) vs. E output histogram.
//          In case "hin" contains a regular dN/dx distribution, "fscale" should not
//          be specified.
//
// Returned object : The 1-D histogram (TH1F) containing the expected counts N vs. x.
//
// The default values are s="" and fscale=0.

Definition at line 9666 of file NcAstrolab.cxx.

GetCredibleInterval() [1/4]

Double_t NcAstrolab::GetCredibleInterval	(	TF1	pdf,
		Double_t	p,
		Double_t &	xlow,
		Double_t &	xup,
		Int_t	n = 1000 )

// Provide lower and upper bounds of the Bayesian "p%" credible interval
// around the mode of the specified PDF.
//
// Note : The results are provided for the current range (see TF1::SetRange) of the PDF.
//        which is reflected in e.g. TF1::Draw().
//        For a good interpretation of the returned values, the user has to make sure
//        that the range covers the full PDF.
//        This range is automatically set if the PDF is the result of the
//        memberfunctions GetBackgroundRatePDF() or GetSignalRatePDF(). 
//
// Input arguments :
// -----------------
// pdf  : The PDF to be analysed.
//        This PDF does not have to be normalised.
// p    : The percentage of the PDF to be covered by the credible interval around the mode.
//        So for a Gaussian PDF, p=68.3 will result in the [mean-sigma,mean+sigma] 68.3% credible interval.
// xlow : The variable for the return of the lower bound of the credible interval. 
// xup  : The variable for the return of the upper bound of the credible interval. 
// n    : The number of intervals (i.e. quantiles) to be scanned, which determines the precision
//        of the results as explained below.
//
// The return value is the resulting fraction of the PDF covered between [xlow,xup].
// The accuracy of this resulting fraction is better than 1/n.
// By default n=1000 which implies that the accuracy of the resulting fraction is better than 0.1%.
// Note that very large values of "n" may result in a rather long computation time. 
//
// In case of inconsistent data all returned values are 0.  

Definition at line 10232 of file NcAstrolab.cxx.

GetCredibleInterval() [2/4]

Double_t NcAstrolab::GetCredibleInterval	(	TF1	pdf,
		Double_t	p,
		Float_t &	xlow,
		Float_t &	xup,
		Int_t	n = 1000 )

// Provide lower and upper bounds of the Bayesian "p%" credible interval
// around the mode of the specified PDF.
//
// Note : The results are provided for the current range (see TF1::SetRange) of the PDF.
//        which is reflected in e.g. TF1::Draw().
//        For a good interpretation of the returned values, the user has to make sure
//        that the range covers the full PDF.
//        This range is automatically set if the PDF is the result of the
//        memberfunctions GetBackgroundRatePDF() or GetSignalRatePDF(). 
//
// Input arguments :
// -----------------
// pdf  : The PDF to be analysed.
//        This PDF does not have to be normalised.
// p    : The percentage of the PDF to be covered by the credible interval around the mode.
//        So for a Gaussian PDF, p=68.3 will result in the [mean-sigma,mean+sigma] 68.3% credible interval.
// xlow : The variable for the return of the lower bound of the credible interval. 
// xup  : The variable for the return of the upper bound of the credible interval. 
// n    : The number of intervals (i.e. quantiles) to be scanned, which determines the precision
//        of the results as explained below.
//
// The return value is the resulting fraction of the PDF covered between [xlow,xup].
// The accuracy of this resulting fraction is better than 1/n.
// By default n=1000 which implies that the accuracy of the resulting fraction is better than 0.1%.
// Note that very large values of "n" may result in a rather long computation time. 
//
// In case of inconsistent data all returned values are 0.  

Definition at line 10374 of file NcAstrolab.cxx.

GetCredibleInterval() [3/4]

Double_t NcAstrolab::GetCredibleInterval	(	TH1 *	his,
		Double_t	p,
		Double_t &	xlow,
		Double_t &	xup )

// Provide lower and upper bounds of the Bayesian "p%" credible interval
// around the mode of the specified histogram.
//
// Input arguments :
// -----------------
// his  : The histogram to be analysed.
//        This hitogram does not have to be normalised.
// p    : The percentage of the total integral to be covered by the credible interval around the mode.
//        So for a Gaussian, p=68.3 will result in the [mean-sigma,mean+sigma] 68.3% credible interval.
// xlow : The variable for the return of the lower bound of the credible interval. 
// xup  : The variable for the return of the upper bound of the credible interval. 
//
// The return value is the resulting fraction of the integral covered between [xlow,xup].
//
// Note : The accuracy of the results is depending on the bin size of the histogram.
//
// In case of inconsistent data all returned values are 0.  

Definition at line 10419 of file NcAstrolab.cxx.

GetCredibleInterval() [4/4]

Double_t NcAstrolab::GetCredibleInterval	(	TH1 *	his,
		Double_t	p,
		Float_t &	xlow,
		Float_t &	xup )

// Provide lower and upper bounds of the Bayesian "p%" credible interval
// around the mode of the specified histogram.
//
// Input arguments :
// -----------------
// his  : The histogram to be analysed.
//        This hitogram does not have to be normalised.
// p    : The percentage of the total integral to be covered by the credible interval around the mode.
//        So for a Gaussian, p=68.3 will result in the [mean-sigma,mean+sigma] 68.3% credible interval.
// xlow : The variable for the return of the lower bound of the credible interval. 
// xup  : The variable for the return of the upper bound of the credible interval. 
//
// The return value is the resulting fraction of the integral covered between [xlow,xup].
//
// Note : The accuracy of the results is depending on the bin size of the histogram.
//
// In case of inconsistent data all returned values are 0.

Definition at line 10533 of file NcAstrolab.cxx.

GetCumulHistogram() [1/2]

TH1F NcAstrolab::GetCumulHistogram	(	TF1 *	f,
		TString	name,
		Int_t	nbins,
		Double_t	xmin,
		Double_t	xmax,
		TString	mode = "F" ) const

// Provide the Cumulative Distribution Histogram from the input 1-D function "f".
//
// Input arguments :
// -----------------
// f     : Input 1-D function from which the cumulative distribution will be determined
// name  : Name for the newly created histogram which contains the cumulative distribution
// nbins : The number of bins for the output histogram
// xmin  : Minimum x value for the output histogram
// xmax  : Maximum x value for the output histogram
// mode  : "F" --> Determine the cumulative distribution in the forward sense  
//         "B" --> Determine the cumulative distribution in the backward sense  
//         "N" --> Determine the cumulative distribution normalized to 1
//
// Examples :
// ----------
// mode="BN" will provide the backward cumulative distribution, normalized to 1.
// mode="BFN" will provide an empty cumulative distribution (conflicting input).
//
// The default is mode="F".
//
// In case of inconsistent input, an empty cumulative distribution histogram will be returned.
//
//--- Nick van Eijndhoven 26-nov-2018 IIHE-VUB Brussel

Definition at line 10955 of file NcAstrolab.cxx.

GetCumulHistogram() [2/2]

TH1F NcAstrolab::GetCumulHistogram	(	TH1 *	h,
		TString	name,
		TString	mode = "F" ) const

// Provide the Cumulative Distribution Histogram from the input 1-D histogram "h".
//
// Input arguments :
// -----------------
// h    : Input 1-D histogram from which the cumulative distribution will be determined
// name : Name for the newly created histogram which contains the cumulative distribution
// mode : "F" --> Determine the cumulative distribution in the forward sense  
//        "B" --> Determine the cumulative distribution in the backward sense  
//        "N" --> Determine the cumulative distribution normalized to 1
//
// Examples :
// ----------
// mode="BN" will provide the backward cumulative distribution, normalized to 1.
// mode="BFN" will provide an empty cumulative distribution (conflicting input).
//
// The default is mode="F".
//
// Note : Underflow and Overflow entries are not taken into account.
//
// In case of inconsistent input, an empty cumulative distribution histogram will be returned.
//
//--- Nick van Eijndhoven 26-nov-2018 IIHE-VUB Brussel

Definition at line 10864 of file NcAstrolab.cxx.

GetDifference() [1/6]

Double_t NcAstrolab::GetDifference	(	Int_t	jref,
		TString	au,
		Double_t &	dt,
		TString	tu,
		Int_t	mode = 1,
		Int_t *	ia = 0,
		Int_t *	it = 0 )

// ************************************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility.             ***
// *** The user is advised to use the memberfunction GetSeparation() or MatchSignals() instead. ***
// ************************************************************************************************
//
// Provide space and time difference between the j-th reference signal
// (j=1 indicates first) and the single stored measurement at storage index 1.
// 
// The return value of this memberfunction provides the positional angular
// difference, whereas the output argument "dt" provides the time difference.
//
// The units of the angular difference can be specified via the the "au"
// input argument, where
//
// au = "rad" --> Angular difference in (fractional) radians
//      "deg" --> Angular difference in (fractional) degrees
//
// The units of the time difference can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
// Also here mode=1 is the default value.
//
// For the time difference the reference signal is used as the standard.
// This means that in case of a positive time difference, the stored
// measurement occurred later than the reference signal.
//
// In case j=0, the stored measurement will be compared with each
// reference signal and the returned angular and time differences are
// the minimal differences which were encountered.
// In this case the user may obtain the indices of the two stored reference signals
// which had the minimal angular and minimal time difference via the output
// arguments "ia" and "it" as follows :
//
// ia = Index of the stored reference signal with minimial angular difference
// it = Index of the stored reference signal with minimial time difference
//
// In case these indices are the same, there obviously was 1 single reference signal
// which showed both the minimal angular and time difference.
//
// The default values are mode=1, ia=0 and it=0;
//
// Note : In case scrambling has been activated, the results will be scrambled accordingly.

Definition at line 4811 of file NcAstrolab.cxx.

GetDifference() [2/6]

Int_t NcTimestamp::GetDifference	(	NcTimestamp &	t,
		Int_t &	days,
		Int_t &	sec,
		Int_t &	ns,
		Int_t &	ps,
		TString	type = "UT" )

// Provide the time difference w.r.t the NcTimestamp specified on the input.
// This memberfunction supports both very small (i.e. time of flight analysis
// for particle physics experiments) and very long (i.e. investigation of
// astrophysical phenomena) time intervals.
//
// The input argument "type" allows to specify the time recording system
// type : "UT"  ==> Time difference is provided according to the UT day counting
//        "TAI" ==> Time difference is provided according to the TAI day counting
//
// Note :
// ------
// In case type="TAI" and the TAI recording was not activated for one (or both) of the timestamps,
// the time difference will be set to 0.
// The UT recording is always available, and in case of a mix of UT1 and UTC as reference times
// for the two timestamps, the time difference will be determined on basis of UTC.
// Obviously, the time difference based on UTC will be less accurate than the time difference
// determined on basis of UT1 for both timestamps.
//
// The default value is type="UT", which is to be used for accurate astrophysical observations.
//
// Full picosecond accuracy is automatically obtained by using the same "type" as with which
// both the timestamps have been set (i.e. SetTAI() or SetGPS() and using type="TAI" 
// or via the SetUT() related facilities and using type="UT").
// Otherwise, the time difference accuracy amounts to the one of dUT=UT-UTC.
// For timestamps that have the same UTC parameters (i.e. Leap Seconds and dUT=UT-UTC),
// both the "UT" and "TAI" systems provide the same time difference (within the dUT accuracy).
//
// The time difference is returned via the following output arguments :
// d  : elapsed number of days
// s  : remaining elapsed number of seconds
// ns : remaining elapsed number of nanoseconds
// ps : remaining elapsed number of picoseconds
//
// Note :
// ------
// The calculated time difference is the absolute value of the time interval.
// This implies that the values of d, s, ns and ps are always positive or zero.
//
// The integer return argument indicates whether the NcTimestamp specified
// on the input argument occurred earlier (-1), simultaneously (0) or later (1).
//
// In case of inconsistent input the time difference and the return argument will be set to 0.

Definition at line 79 of file NcTimestamp.cxx.

GetDifference() [3/6]

Double_t NcTimestamp::GetDifference	(	NcTimestamp &	t,
		TString	u,
		Int_t	mode = 1,
		TString	type = "UT" )

// Provide the time difference w.r.t the NcTimestamp specified on the input
// in the units as specified by the TString "u" argument.
// A positive return value means that the NcTimestamp specified on the input
// argument occurred later, whereas a negative return value indicates an
// earlier occurence. 
//
// The input argument "type" allows to specify the time recording system
// type : "UT"  ==> Time difference is provided according to the UT day counting
//        "TAI" ==> Time difference is provided according to the TAI day counting
//
// Note :
// ------
// In case type="TAI" and the TAI recording was not activated for one (or both) of the timestamps,
// the time difference will be set to 0.
// The UT recording is always available, and in case of a mix of UT1 and UTC as reference times
// for the two timestamps, the time difference will be determined on basis of UTC.
// Obviously, the time difference based on UTC will be less accurate than the time difference
// determined on basis of UT1 for both timestamps.
//
// The default value is type="UT", which is to be used for accurate astrophysical observations.
//
// Full picosecond accuracy is automatically obtained by using the same "type" as with which
// both the timestamps have been set (i.e. SetTAI() or SetGPS() and using type="TAI" 
// or via the SetUT() related facilities and using type="UT").
// Otherwise, the time difference accuracy amounts to the one of dUT=UT-UTC.
// For timestamps that have the same UTC parameters (i.e. Leap Seconds and dUT=UT-UTC),
// both the "UT" and "TAI" systems provide the same time difference (within the dUT accuracy).
//  
// The units may be specified as :
// u = "d"  ==> Time difference returned as (fractional) day count
//     "s"  ==> Time difference returned as (fractional) second count
//     "ns" ==> Time difference returned as (fractional) nanosecond count
//     "ps" ==> Time difference returned as picosecond count
//
// It may be clear that for a time difference of several days, the picosecond
// and even the nanosecond accuracy may be lost.
// To cope with this, the "mode" argument has been introduced to allow 
// timestamp comparison on only the specified units.
//
// The following operation modes are supported :
// mode = 1 : Full time difference is returned in specified units
//        2 : Time difference is returned in specified units by
//            neglecting the elapsed time for the larger units than the
//            ones specified.
//        3 : Time difference is returned in specified units by only
//            comparing the timestamps on the level of the specified units.
//
// Example :
// ---------
// NcTimestamp t1; // Corresponding to days=3, secs=501, ns=31, ps=7 
// NcTimestamp t2; // Corresponding to days=5, secs=535, ns=12, ps=15
//
// The statement : Double_t val=t1.GetDifference(t2,....)
// would return the following values :
// val=(2*24*3600)+34-(19*1e-9)+(8*1e-12) for u="s" and mode=1
// val=34-(19*1e-9)+(8*1e-12)             for u="s" and mode=2
// val=34                                 for u="s" and mode=3
// val=-19                                for u="ns" and mode=3
//
// The default is mode=1.
//
// In case of inconsistent input the time difference will be set to 0.

Definition at line 81 of file NcTimestamp.cxx.

GetDifference() [4/6]

Int_t NcTimestamp::GetDifference	(	NcTimestamp *	t,
		Int_t &	days,
		Int_t &	sec,
		Int_t &	ns,
		Int_t &	ps,
		TString	type = "UT" )

// Provide the time difference w.r.t the NcTimestamp specified on the input.
// This memberfunction supports both very small (i.e. time of flight analysis
// for particle physics experiments) and very long (i.e. investigation of
// astrophysical phenomena) time intervals.
//
// The input argument "type" allows to specify the time recording system
// type : "UT"  ==> Time difference is provided according to the UT day counting
//        "TAI" ==> Time difference is provided according to the TAI day counting
//
// Note :
// ------
// In case type="TAI" and the TAI recording was not activated for one (or both) of the timestamps,
// the time difference will be set to 0.
// The UT recording is always available, and in case of a mix of UT1 and UTC as reference times
// for the two timestamps, the time difference will be determined on basis of UTC.
// Obviously, the time difference based on UTC will be less accurate than the time difference
// determined on basis of UT1 for both timestamps.
//
// The default value is type="UT", which is to be used for accurate astrophysical observations.
//
// Full picosecond accuracy is automatically obtained by using the same "type" as with which
// both the timestamps have been set (i.e. SetTAI() or SetGPS() and using type="TAI" 
// or via the SetUT() related facilities and using type="UT").
// Otherwise, the time difference accuracy amounts to the one of dUT=UT-UTC.
// For timestamps that have the same UTC parameters (i.e. Leap Seconds and dUT=UT-UTC),
// both the "UT" and "TAI" systems provide the same time difference (within the dUT accuracy).
//
// The time difference is returned via the following output arguments :
// d  : elapsed number of days
// s  : remaining elapsed number of seconds
// ns : remaining elapsed number of nanoseconds
// ps : remaining elapsed number of picoseconds
//
// Note :
// ------
// The calculated time difference is the absolute value of the time interval.
// This implies that the values of d, s, ns and ps are always positive or zero.
//
// The integer return argument indicates whether the NcTimestamp specified
// on the input argument occurred earlier (-1), simultaneously (0) or later (1).
//
// In case of inconsistent input the time difference and the return argument will be set to 0.

Definition at line 78 of file NcTimestamp.cxx.

GetDifference() [5/6]

Double_t NcTimestamp::GetDifference	(	NcTimestamp *	t,
		TString	u,
		Int_t	mode = 1,
		TString	type = "UT" )

// Provide the time difference w.r.t the NcTimestamp specified on the input
// in the units as specified by the TString "u" argument.
// A positive return value means that the NcTimestamp specified on the input
// argument occurred later, whereas a negative return value indicates an
// earlier occurence. 
//
// The input argument "type" allows to specify the time recording system
// type : "UT"  ==> Time difference is provided according to the UT day counting
//        "TAI" ==> Time difference is provided according to the TAI day counting
//
// Note :
// ------
// In case type="TAI" and the TAI recording was not activated for one (or both) of the timestamps,
// the time difference will be set to 0.
// The UT recording is always available, and in case of a mix of UT1 and UTC as reference times
// for the two timestamps, the time difference will be determined on basis of UTC.
// Obviously, the time difference based on UTC will be less accurate than the time difference
// determined on basis of UT1 for both timestamps.
//
// The default value is type="UT", which is to be used for accurate astrophysical observations.
//
// Full picosecond accuracy is automatically obtained by using the same "type" as with which
// both the timestamps have been set (i.e. SetTAI() or SetGPS() and using type="TAI" 
// or via the SetUT() related facilities and using type="UT").
// Otherwise, the time difference accuracy amounts to the one of dUT=UT-UTC.
// For timestamps that have the same UTC parameters (i.e. Leap Seconds and dUT=UT-UTC),
// both the "UT" and "TAI" systems provide the same time difference (within the dUT accuracy).
//
// The units may be specified as :
// u = "d"  ==> Time difference returned as (fractional) day count
//     "s"  ==> Time difference returned as (fractional) second count
//     "ns" ==> Time difference returned as (fractional) nanosecond count
//     "ps" ==> Time difference returned as picosecond count
//
// It may be clear that for a time difference of several days, the picosecond
// and even the nanosecond accuracy may be lost.
// To cope with this, the "mode" argument has been introduced to allow 
// timestamp comparison on only the specified units.
//
// The following operation modes are supported :
// mode = 1 : Full time difference is returned in specified units
//        2 : Time difference is returned in specified units by
//            neglecting the elapsed time for the larger units than the
//            ones specified.
//        3 : Time difference is returned in specified units by only
//            comparing the timestamps on the level of the specified units.
//
// Example :
// ---------
// NcTimestamp t1; // Corresponding to days=3, secs=501, ns=31, ps=7 
// NcTimestamp t2; // Corresponding to days=5, secs=535, ns=12, ps=15
//
// The statement : Double_t val=t1.GetDifference(t2,....)
// would return the following values :
// val=(2*24*3600)+34-(19*1e-9)+(8*1e-12) for u="s" and mode=1
// val=34-(19*1e-9)+(8*1e-12)             for u="s" and mode=2
// val=34                                 for u="s" and mode=3
// val=-19                                for u="ns" and mode=3
//
// The default is mode=1.
//
// In case of inconsistent input the time difference will be set to 0.

Definition at line 80 of file NcTimestamp.cxx.

GetDifference() [6/6]

Double_t NcAstrolab::GetDifference	(	TString	name,
		TString	au,
		Double_t &	dt,
		TString	tu,
		Int_t	mode = 1 )

// ************************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility. ***
// *** The user is advised to use the memberfunction GetSeparation() instead.       ***
// ************************************************************************************
//
// Provide space and time difference between the stored reference signal
// with the specified name and the single stored measurement at storage index 1.
//
// Note : In case the name specifies a solar system object supported by SetSolarSystem()
//        which was not yet stored as a reference signal, the corresponding reference signal
//        will be created and stored with the current timestamp of this NcAstrolab instance. 
// 
// The return value of this memberfunction provides the positional angular
// difference, whereas the output argument "dt" provides the time difference.
//
// The units of the angular difference can be specified via the the "au"
// input argument, where
//
// au = "rad" --> Angular difference in (fractional) radians
//      "deg" --> Angular difference in (fractional) degrees
//
// The units of the time difference can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
// Also here mode=1 is the default value.
//
// For the time difference the reference signal is used as the standard.
// This means that in case of a positive time difference, the stored
// measurement occurred later than the reference signal.
//
// Note : In case scrambling has been activated, the results will be scrambled accordingly.

Definition at line 5310 of file NcAstrolab.cxx.

GetDifHistogram()

TH1F NcAstrolab::GetDifHistogram	(	TH1 *	hin,
		Int_t	mode,
		TString	s = "",
		TF1 *	f = 0 ) const

// Construct a differential dy/dx vs. x histogram from a 1D regular y vs. x input histogram.
// Such a returned histogram allows an easy fitting of differential exponential and power spectra
// in the case of unequal (or logarithmic) bin sizes.
//
// Example :
// ---------
// The input histogram represents the number of counts (N) in (variable) energy (E) bins and
// these N vs. E data are used to investigate the match with some theoretical dN/dE prediction.
// The returned histogram provides the correctly normalised dN/dE distribution which can directly
// be compared with the model prediction via the appropriate fit.
// By providing the optional function "f" as for instance TF1 f("f","pow(x,2.)")
// the returned histogram reflects the E^2 dN/dE distribution.
// 
//            
//
// Input arguments :
// -----------------
// hin  : The input histogram
// mode : 0 ==> X-axis represents the x value
//        1 ==> X-axis represents the Log10(x) value
//        2 ==> X-axis represents the Ln(x) value
// s    : Character string for the Y-axis label of the returned histogram
//        If string s is not provided the label will be constructed from the
//        labels of the input histogram.
// f    : Optional 1-D function to rescale the Y-values of the returned histogram.
//        The variable "x" of this function (if used in the function description)
//        represents the central value of each X-axis bin.
//        If function f is not provided no rescaling of the Y-values will be performed. 
//
// Returned object : The 1-D histogram (TH1F) containing dy/dx at the Y-axis.

Definition at line 9417 of file NcAstrolab.cxx.

GetDxHistogram()

TH1F NcAstrolab::GetDxHistogram	(	TH1 *	hx,
		Int_t	nc,
		Double_t	dxbin = -1,
		Double_t	dxmin = -1,
		Double_t	dxmax = -1,
		Int_t	mode = 1,
		Double_t	fact = 1 )

// Provide the interval size (dx) distribution of X-axis intervals between a certain
// fixed amount of consecutive histogram entries of the specified input histogram.
// This facility can for instance be used to investigate the distribution
// of time intervals between observed events.
//
// Input arguments :
// -----------------
// hx    : The input histogram.
// nc    : The step count to arrive at the required consecutive entry (see example below).
// dxbin : The bin size of the X-axis for the dx distribution (see also the note below).
//         dxbin=0  ==> Bin size taken the same as the input histogram "hx".
//         dxbin=-1 ==> Bin size taken to be the minimal encountered dx interval,
//                      or "fact" times the bin size of the input histogram "hx", if the latter
//                      is the larger. This provides a protection against too small bin sizes,
//                      and consequently a very large number of bins, in case an extremely small
//                      dx interval value is encountered.
//                      In case "fact<=0" and the minimal dx interval encountered was 0,
//                      the bin size of the input histogram "hx" is taken. 
//         dxbin=-2 ==> Bin size taken to be "nc" times the bin size of the input histogram "hx".
// dxmin : The lower bound of the produced histogram.
//         dxmin<0 ==> Lower bound taken to be the minimal encountered dx interval.
// dxmax : The upper bound of the produced histogram.
//         dxmax<0 ==> Upper bound taken to be the maximal encountered dx interval
//                     increased with one additional bin size to contain the maximal
//                     encountered dx interval value in the output histogram.
// mode  : 0 ==> Bin contents of the input histogram "hx" are regarded as event counts
//               (rounded to the nearest integer) with as x-value the center of the bin.
//               Multiple entries in the same bin are treated as multiple events with exactly
//               the same x-value, possibly resulting in interval values dx=0.
//               See also note 1) below.
//         1 ==> Same as "mode=0", but the x-value of each entry of the input histogram "hx" will be
//               assigned to a uniform random value within the corresponding bin. See note 1) below.  
//         2 ==> Bin contents of the input histogram "hx" are treated as (weighted) values.
//               Each filled bin is treated as a single event with as x-value the center of the bin.
//         3 ==> Same as "mode=2", but the x-value of each entry of the input histogram "hx" will be
//               assigned to a uniform random value within the corresponding bin. See also note 1) below.
// fact  : Multiplication factor applied to the bin size of the input histogram "hx" to provide
//         a lower limit to the bin size of the produced Dx histogram when "dxbin=-1". See note 1) below.
//
// Returned object : The 1-D histogram (TH1F) containing the dx distribution.
//
// Default values : dxbin=-1, dxmin=-1, dxmax=-1, mode=1 and fact=1.
//
// Note : A too coarse bin size "dxbin" may lead to binning effects which may affect
//        a statistical interpretation of the resulting histogram, for instance in the
//        light of a comparison with known background distributions.
//        In case the input histogram "hx" reflects an unbinned situation, i.e. not more
//        than one single entry per bin, then "dxbin=0" assures that also the produced
//        "dx histogram" will be free of binning effects.
//        For sparsely populated histograms, the same may hold for "dxbin=-2", which has
//        the advantage of having fewer bins which may reduce computing time when
//        performing statistical analyses (e.g. randomised combinatorics) on it.
//        It is advised to always first inspect the produced "dx histogram" before
//        performing a statistics analysis on it.
//
// Example :
// ---------
// Histogram "hx" contains the counts of event times according to a Poisson distribution.
// Specifying "nc=1" will provide the histogram of dt intervals between each consecutive event,
// i.e. the distribution of time intervals between the events (1,2), (2,3), (3,4) etc.
// Specifying "nc=2" will provide the histogram of dt intervals between every 2nd consecutive event,
// i.e. the distribution of time intervals between the events (1,3), (2,4), (3,5) etc.
// In this case of a Poissonian input histogram these produced dt distributions are known
// as the Erlang distributions (see also class NcMath), for which each time interval contains
// exactly "nc" events of which the last event occurs right at the end of the interval.
//
// Notes :
// -------
// 1) In case a certain bin of the input histogram "hx" contains several entries, all these
//    entries are regarded as separate entities with exactly the same x-value.
//    Consequently, this may result in (several) dx intervals of value 0, resulting in
//    entries at 0 in the output histogram.
//    In case one wants to avoid this effect, the binning of the input histogram "hx" could be
//    chosen fine enough to reflect a basically unbinned situation.
//    Another way to avoid this effect is to specify "mode=1", for which all entries in the
//    input histogram "hx" will be assigned a uniform random value within the corresponding bin,
//    instead of the usual center of bin value.
//    The "sensitivity" to this randomisation effect can be tuned by the input argument "fact"
//    which controls the minimal bin size of the produced Dx histogram.
//    Yet another way of avoiding this effect is to specify "mode=2" or "mode=3", which will treat
//    every filled bin of the input histogram as a single event, irrespective of the bin content.
//    These modes 2 or 3 allow the treatment of input histograms for which the bin contents do
//    not represent event counts, e.g. histograms which have been rescaled or filled with weights.
// 2) In case "dxmax<0" the actual bin size of the output histogram (slightly) differs from the
//    provided one because of the addition of one or two bin size(s) to the auto-detected dxmax
//    in order to prevent entries to fall outside the histogram range. 
//    If one wants multiple output histograms resulting from multiple invokations of this function
//    to have identical range and bin size, the user is advised to obtain the output histogram
//    parameters from the first produced histogram and pass these to the subsequent invokations.
// 3) For "mode=1" and "mode=3" a random number sequence is used, which may yield (slightly) different
//    results for multiple invokations. The start of the random number sequence may be synchronised
//    by invokation of the member function SetRandomiser().
// 4) This member function is used recursively.

Definition at line 9154 of file NcAstrolab.cxx.

GetExperiment()

TString NcAstrolab::GetExperiment

(

)

const

// Provide the name of the experiment site.

Definition at line 1061 of file NcAstrolab.cxx.

GetHourAngle()

Double_t NcAstrolab::GetHourAngle	(	TString	mode,
		NcTimestamp *	ts,
		Int_t	jref = 0,
		Int_t	type = 0 )

// Provide the Local Hour Angle (in fractional degrees) of a stored signal
// object at the specified timestamp.
// The hour angle is provided within the interval [-180,180], where
// negative (positive) values indicate positions East (West) of the observers meridian.
//
// The input parameter "mode" allows the user to select either the
// "mean" or "apparent" value for the returned Hour Angle.
//
// mode = "M" --> Output is the Mean Hour Angle
//        "A" --> Output is the Apparent Hour Angle
// ts   : Timestamp at which the hour angle is requested.
//
// The input parameters "jref" and "type" allow to specify measured or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Use the signal at the j-th position (j=1 is first)
//
// type = 0 --> Select a stored reference signal
//        1 --> Select a stored measurement
//
// Note :
// ------
// For jref=0 always the first stored measurement will be selected for backward compatibility,
// but the user is advised not to use this obsolete method anymore.
//
// Default values are jref=0 and type=0.
//
// Note : In case ts=0 the current timestamp of the lab will be taken.

Definition at line 4616 of file NcAstrolab.cxx.

GetHubbleParameter()

Double_t NcAstrolab::GetHubbleParameter	(	Double_t	z,
		TString	u = "Mpc" ) const

// Provide the Hubble parameter H(z) at a certain redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The input argument "u" allows specification of the required units,
// with the following options:
//
// u = "Gpc" (H(z) in km/s per Giga parsec)
//     "Mpc" (H(z) in km/s per Mega parsec)
//     "pc"  (H(z) in km/s per parsec)
//     "ly"  (H(z) in km/s per light year)
//     "km"  (H(z) in km/s per kilometer)
//     "m"   (H(z) in km/s per meter)
//     "cm"  (H(z) in km/s per centimeter)
//
// The default is u="Mpc" for backward compatibility
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 8010 of file NcAstrolab.cxx.

GetInteractionProbability() [1/2]

Double_t NcAstrolab::GetInteractionProbability	(	Double_t	x,
		Double_t	lambda ) const

// Provide the interaction probability of a high-energy particle traveling
// a distance "x" through a certain medium.
//
// For a mono-energetic beam of identical particles, this probability allows
// to calculate the interaction rate once the beam luminosity is known.
//
// Input arguments :
// -----------------
// x      : The distance traveled by the particle inside the medium
// lambda : The mean free path of the particle in the medium
//
// The formula used is : prob=1-exp(-x/lambda).
//
// So, when x=lambda, the interaction probability is about 0.63.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// Notes :
// -------
// 1) "x" and "lambda" have to be specified in the same units.
// 2) The probability of pair production by a high-energy photon
//    may be obtained from the corresponding radiation length X0
//    by using the fact that lambda=X0*9/7.
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8284 of file NcAstrolab.cxx.

GetInteractionProbability() [2/2]

Double_t NcAstrolab::GetInteractionProbability	(	Double_t	x,
		Double_t	sigma,
		Double_t	rho,
		Int_t	mode ) const

// Provide the interaction probability of a high-energy particle traveling
// a distance "x" through a certain medium.
// The input parameter "mode" dictates the units of "x" and "rho" (see below).
//
// For a mono-energetic beam of identical particles, this probability allows
// to calculate the interaction rate once the beam luminosity is known.
//
// Input arguments :
// -----------------
// x     : The distance traveled by the particle inside the medium (see below)
// sigma : The interaction cross section in barn (1 barn=1e-24 cm^2)
// rho   : The density of the medium (see below)
// mode  : 0 --> rho=#particles/cm^3 and [x]=cm
//         1 --> rho=#particles/cm^3 and [x]=#particles/cm^2
//         2 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=cm
//         3 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=g/cm^2
//         4 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=#nucleons/cm^2
//
// The formula used is : prob=1-exp(-x/lambda),
// where lambda is the corresponding mean free path.
//
// So, when x=lambda, the interaction probability is about 0.63.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8326 of file NcAstrolab.cxx.

GetLabDetectorId()

Int_t NcAstrolab::GetLabDetectorId

(

)

const

// Provide the detector identifier within the lab.

Definition at line 1072 of file NcAstrolab.cxx.

GetLabPosition() [1/2]

NcPosition NcAstrolab::GetLabPosition

(

)

const

// Provide the lab position in the terrestrial coordinates.
// The right handed position reference frame is defined such that the North Pole
// corresponds to a polar angle theta=0 and the Greenwich meridian corresponds
// to an azimuth angle phi=0, with phi increasing eastwards.

Definition at line 1018 of file NcAstrolab.cxx.

GetLabPosition() [2/2]

void NcAstrolab::GetLabPosition	(	Double_t &	l,
		Double_t &	b,
		TString	u = "deg" ) const

// Provide the lab position in the terrestrial longitude (l) and latitude (b).
// Positions north of the equator have b>0, whereas b<0 indicates
// locations south of the equator.
// Positions east of Greenwich have l>0, whereas l<0 indicates
// locations west of Greenwich.
//
// The string argument "u" allows to choose between different angular units
// u = "rad" : angles provided in radians
//     "deg" : angles provided in degrees
//
// The default is u="deg".

Definition at line 1032 of file NcAstrolab.cxx.

GetLabTimeOffset()

Double_t NcAstrolab::GetLabTimeOffset

(

)

const

// Provide the lab time offset (dt) w.r.t. UT in (fractional) hours.
// This time offset is automatically set by invokation of the memberfunctions
// SetPosition() or SetExperiment().

Definition at line 1083 of file NcAstrolab.cxx.

GetLAST() [1/2]

Double_t NcAstrolab::GetLAST

(

)

// Provide the Lab's Local Apparent Sidereal Time (LAST) in fractional hours.
// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
// The definition of GMST and GAST is such that a sidereal clock corresponds with
// 24 sidereal hours per revolution of the Earth.
// As such, local time offsets w.r.t. UT, GMST and GAST can be treated similarly. 
//
// In case a hh:mm:ss format is needed, please use the Convert() facility. 

Definition at line 1239 of file NcAstrolab.cxx.

GetLAST() [2/2]

Double_t NcTimestamp::GetLAST

(

Double_t

offset

)

// Provide the corresponding Local Apparent Sidereal Time (LAST) in fractional hours.
// The "offset" denotes the time difference in (fractional) hours w.r.t. GAST.
// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
// The definition of GMST and GAST is such that a sidereal clock corresponds with
// 24 sidereal hours per revolution of the Earth.
// As such, local time offsets w.r.t. UT, GMST and GAST can be treated similarly. 
//
// In case a hh:mm:ss.sss format is needed, please use the Convert() facility. 

Definition at line 95 of file NcTimestamp.cxx.

GetLightTravelDistance()

Double_t NcAstrolab::GetLightTravelDistance	(	Double_t	z,
		TString	u = "Mpc" ) const

// Provide the light-travel distance of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The light-travel distance reflects the distance (c*dt) that light has traveled
// to reach us from an object observed with a redshift z.
//
// The light-travel distance is determined via a similar integral as the physical distance,
// but taking into account an extra term 1/(1+z) in the integrand.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The light-travel time may be obtained by dividing the light-travel distance by
// the lightspeed. Alternatively, expressing the light-travel distance in units
// of light years (ly) reflects directly the light-travel time in years.
//
// The input argument "u" allows specification of the required distance units,
// with the following options:
//
// u = "Gpc" (distance in Giga parsec)
//     "Mpc" (distance in Mega parsec)
//     "pc"  (distance in parsec)
//     "ly"  (distance in light years)
//     "km"  (distance in kilometers)
//     "m"   (distance in meters)
//     "cm"  (distance in centimeters)
//
// The default is u="Mpc" for backward compatibility
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 7920 of file NcAstrolab.cxx.

GetLightTravelTime()

Double_t NcAstrolab::GetLightTravelTime

(

Double_t

z

)

const

// Provide the light-travel time (in years) of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The light-travel time reflects the time that light has traveled
// to reach us from an object observed with a redshift z.
//
// The light-travel time is also called the look back time.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The light-travel time is obtained by dividing the light-travel distance by
// the lightspeed.

Definition at line 7985 of file NcAstrolab.cxx.

GetLMST() [1/2]

Double_t NcAstrolab::GetLMST

(

)

// Provide the Lab's Local Mean Sidereal Time (LMST) in fractional hours.
// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
// The definition of GMST is such that a sidereal clock corresponds with
// 24 sidereal hours per revolution of the Earth.
// As such, local time offsets w.r.t. UT and GMST can be treated similarly. 
//
// In case a hh:mm:ss format is needed, please use the Convert() facility. 

Definition at line 1221 of file NcAstrolab.cxx.

GetLMST() [2/2]

Double_t NcTimestamp::GetLMST

(

Double_t

offset

)

// Provide the corresponding Local Mean Sidereal Time (LMST) in fractional hours.
// The "offset" denotes the time difference in (fractional) hours w.r.t. GMST.
// A sidereal day corresponds to 23h 56m 04.09s (i.e. 86164.09s) mean solar time.
// The definition of GMST is such that a sidereal clock corresponds with
// 24 sidereal hours per revolution of the Earth.
// As such, local time offsets w.r.t. UT and GMST can be treated similarly. 
//
// In case a hh:mm:ss format is needed, please use the Convert() facility. 

Definition at line 94 of file NcTimestamp.cxx.

GetLocalFrame()

void NcAstrolab::GetLocalFrame

(

Float_t

arr[6]

)

// Provide the orientations of the local reference frame axes w.r.t.
// the Master Reference Frame (MRF).
// For details please refer to the memberfunction SetLocalFrame().
//
// Note : The provided array must have a minimum length of 6.

Definition at line 4428 of file NcAstrolab.cxx.

GetLogHistogram()

TH1F NcAstrolab::GetLogHistogram	(	TH1 *	hin,
		Int_t	mode,
		TString	s = "" ) const

// Construct a log10(y) or Ln(y) vs. x histogram from a 1D regular y vs. x input histogram.
// Such a returned histogram allows an easy (linear) fitting of exponential and power spectra.  
//
// Input arguments :
// -----------------
// hin  : The input histogram
// mode : 1 ==> Use Log10(y) for the Y-axis 
//        2 ==> Use Ln(y) for the Y-axis 
// s    : Character string for the Y-axis label of the returned histogram
//        If string s is not provided the label will be constructed from the
//        labels of the input histogram.
//
// Returned object : The 1-D histogram (TH1F) containing the Log10(y) or Ln(y) at the Y-axis.
//
// Note : Bins for which Log10(y) or Ln(y) can not be determined will be left empty.

Definition at line 9775 of file NcAstrolab.cxx.

GetLT() [1/2]

Double_t NcAstrolab::GetLT

(

)

// Provide the Lab's local time in fractional hours.
// A mean solar day lasts 24h (i.e. 86400s).
//
// In case a hh:mm:ss format is needed, please use the Convert() facility. 

Definition at line 1206 of file NcAstrolab.cxx.

GetLT() [2/2]

Double_t NcTimestamp::GetLT

(

Double_t

offset

)

// Provide the corresponding UT based (aka mean solar) Local Time in fractional hours.
// The "offset" denotes the time difference in (fractional) hours w.r.t. UT.
// A mean solar day lasts 24h (i.e. 86400s), so this local time is directly
// related to UT, which is obtained when offset=0.
//
// Note : This local time is often referred to as Local Mean Time (LMT).
//
// In case a hh:mm:ss format is needed, please use the Convert() facility. 

Definition at line 92 of file NcTimestamp.cxx.

GetLuminosityDistance()

Double_t NcAstrolab::GetLuminosityDistance	(	Double_t	z,
		TString	u = "Mpc" ) const

// Provide the luminosity distance of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// Consider an object with known intrinsic luminosity L (erg/s) of which
// a flux F (erg/(s*cm^2) is observed.
// The luminosity distance d is defined such that F=L/(4*pi*d^2), which can
// be alternatively written as d=sqrt(L/(4*pi*F)).
//
// The luminosity distance d can be related to the physical distance D by
// realizing that the observed energy is reduced by a factor (z+1) and that 
// the observed time intervals are stretched by a factor (z+1).
// This results in F=L/[(z+1)*(z+1)*4*pi*D^2] or in other words : d=(z+1)*D.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The input argument "u" allows specification of the required distance units,
// with the following options:
//
// u = "Gpc" (distance in Giga parsec)
//     "Mpc" (distance in Mega parsec)
//     "pc"  (distance in parsec)
//     "ly"  (distance in light years)
//     "km"  (distance in kilometers)
//     "m"   (distance in meters)
//     "cm"  (distance in centimeters)
//
// The default is u="Mpc" for backward compatibility
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 7878 of file NcAstrolab.cxx.

GetMaxDt()

Double_t NcAstrolab::GetMaxDt

(

)

const

// Provide the maximum time difference (in sec) for returning a timestamp related
// (reference) signal via GetSignal.
//
// Note : In case MaxDt<0 no check on the timestamps will be performed and a signal
//        is always returned.

Definition at line 1191 of file NcAstrolab.cxx.

GetMeanFreePath()

Double_t NcAstrolab::GetMeanFreePath	(	Double_t	sigma,
		Double_t	rho,
		Int_t	mode ) const

// Provide the mean free path "lambda" of a high-energy particle passing through a certain medium.
// The input parameter "mode" dictates the units of "rho" and the returned value of "lambda" (see below).
//
// The mean free path (lambda) is the mean distance over which a high-energy particle travels
// inside the medium before an interaction occurs.
// For non (quasi)elastic interactions, this is also called "interaction length",
// "attenuation length" or "absorption length".
//
// The scattering centers (=particles) in the medium are regarded as being stationary,
// such that we can use the formula :
//
// lambda=1/(sigma*n)
//
// where "sigma" represents the cross section and "n" represents the number density
// of the scattering centers in the medium.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// Input arguments :
// -----------------
// sigma : The interaction cross section in barn (1 barn=1e-24 cm^2)
// rho   : The density of the medium (see below)
// mode  : 0 --> rho=#particles/cm^3 and [lambda]=cm
//         1 --> rho=#particles/cm^3 and [lambda]=#particles/cm^2
//         2 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [lambda]=cm
//         3 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [lambda]=g/cm^2
//         4 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [lambda]=#nucleons/cm^2
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8230 of file NcAstrolab.cxx.

GetNeutrinoAngle()

Double_t NcAstrolab::GetNeutrinoAngle	(	Double_t	E,
		TString	u,
		Int_t	mode,
		TF1 *	f = 0 )

// Provide the kinematic opening angle between a neutrino and the corresponding lepton,
// as produced in a CC interaction on a target at rest.
//
// Input arguments :
// -----------------
// E    : The neutrino energy in GeV
// u    : "deg" --> Angle will be returned in degrees 
//        "rad" --> Angle will be returned in radians
// mode : 0 -> Return the mean angle
//        1 -> Return the median angle
//        2 -> Return a random angle based on a parametrisation of the pdf
// f    : Optional argument to obtain the function describing the used pdf
//        In case f=0 no function will be returned.
//
// Note :
// ------
// The pdf for the opening angle has been obtained via simulations using the
// Pythia based NcCollider facility.
// The data for a 1 TeV muon neutrino incident on a proton at rest have been
// fitted by a Landau distribution.
// For other energies, the Landau parameters will be scaled via 1/sqrt(E/(1TeV)).
//
// Usage example :
// ---------------
// Double_t E=500;
// TF1 func;
// Double_t angle=GetNeutrinoAngle(E,"deg",2,&func);
//
// The default value is f=0.
//
// In case of inconsistent data, the unphysical value of -1 will be returned.

Definition at line 8868 of file NcAstrolab.cxx.

GetNeutrinoXsection()

Double_t NcAstrolab::GetNeutrinoXsection	(	Int_t	mode,
		Int_t	type,
		Double_t	egev,
		Double_t	xscale = 1,
		Double_t *	eprimgev = 0,
		Double_t *	alpha = 0 ) const

// Provide the neutrino cross section and (optional) the average energy
// and opening angle of the produced charged lepton (CC) or (anti)neutrino (NC).
// Below 10 TeV the cross section determination is based on a simple linear
// relation between the cross section and the neutrino energy : sigma=f*E.
// The coefficients f for neutrinos and antineutrinos are taken from
// the data of the Particle Data Group and from the publication 
// J.Formaggio and G.Zeller, Rev. Mod. Phys. 84.3 (2012) 1307.
// For energies of 10 TeV and above, the cross section parametrisations of
// A. Connolly et al. (Phys. Rev. D83 (2011) 113009 [ArXiv:1102.0691]) are used.
// The average inelasticity parameter y is obtained from the publication of Gandhi et al.
// (Astroparticle Physics 5 (1996) 81 [ArXiv:hep-ph/9512364]).
// The sigma_nc/sigma_cc ratios for Nucleon DIS are obtained from Gandhi et al.
// (Phys. Rev. D58 (1998) 093009 [ArXiv:hep-ph/9807264]).
//
// Input arguments :
// -----------------
// mode   :  1 --> Nucleon target DIS CC cross section
//           2 --> Nucleon target DIS NC cross section
//           3 --> Nucleon target DIS total cross section
//          -1 --> Electron target CC cross section
//          -2 --> Electron target NC cross section
//          -3 --> Electron target total cross section
//          -4 --> Special CC process anu_e+e-->anu_mu+mu (not included in other mode values)
// type   :  1 --> Electron neutrino
//           2 --> Muon neutrino
//           3 --> Tau neutrino
//          -1 --> Electron anti-neutrino
//          -2 --> Muon anti-neutrino
//          -3 --> Tau anti-neutrino
// egev   : Neutrino energy in GeV
// xscale : Cross section scale for return value (1=barn, 0.001=mb etc...)
//
// Note : 1 cm^2 corresponds to 1e24 barn.
//
// The default value is xscale=1.
//
// Optional output arguments :
// ---------------------------
// eprimgev : Average energy in GeV of the produced charged lepton (CC) or (anti)neutrino (NC).
// alpha    : Average opening angle in degrees between the neutrino and the produced charged lepton (CC) or (anti)neutrino (NC).
//
// In case of incompatible input or unavailable data the value 0 will be returned.

Definition at line 8616 of file NcAstrolab.cxx.

GetNRefSignals()

Int_t NcAstrolab::GetNRefSignals

(

Int_t

mode = 0

)

const

// ************************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility. ***
// *** The user is advised to use the memberfunction GetNsignals() instead.         ***
// ************************************************************************************
//
// Provide the (max. index) number of stored reference signals.
//
// Note : It might be that a user may have removed a reference signal
//        from the storage without compressing the storage array
//        (e.g. for maintaining the original reference signal indices).
//        In such a case the actual storage array may contain reference
//        signals at index values which are larger than the number of
//        actually stored reference signals.
//        The input argument "mode" may be used to obtain this max. index
//        value instead of the number actually stored reference signals.
//
// mode : 0 --> Return the number of actually stored reference signals.
//        1 --> Return the max. index value for stored reference signals
//              (which actually is just the size of the storage array). 
//
// The default value is mode=0.

Definition at line 2250 of file NcAstrolab.cxx.

GetNsignals()

Int_t NcAstrolab::GetNsignals	(	Int_t	type,
		Int_t	mode = 0 ) const

// Provide the (max. index) number of stored signals of type "type".
//
// type = 0 --> The requested number corresponds to the stored reference signals
//        1 --> The requested number corresponds to the stored  measured signals
//
// Note : It might be that a user may have removed a reference signal
//        from the storage without compressing the storage array
//        (e.g. for maintaining the original reference signal indices).
//        In such a case the actual storage array may contain reference
//        signals at index values which are larger than the number of
//        actually stored reference signals.
//        The input argument "mode" may be used to obtain this max. index
//        value instead of the number actually stored reference signals.
//
// mode : 0 --> Return the number of actually stored signals of type "type".
//        1 --> Return the max. index value for stored signals of type "type"
//              (which actually is just the size of the storage array). 
//
// The default value is mode=0.

Definition at line 2282 of file NcAstrolab.cxx.

GetNuclearMass()

Double_t NcAstrolab::GetNuclearMass	(	Int_t	Z,
		Int_t	N,
		Int_t	mode = 1 ) const

// Provide the nuclear mass or binding energy of a specified nucleus
// with "Z" protons and "N" neutrons.
// Here the semi-empirical mass formula is used as indicated on the slides
// of the lecture "Aspects of Nuclear Physics" by Nick van Eijndhoven.
// For very light nuclei this may be inaccurate.
// In view of astrophysical importance, the literature mass values are taken
// for the Deuteron, Triton, Helion and Alpha particles.
//
// Note : In case of an attractive potential, the binding energy is
//        returned as a positive value.
//
// The input argument "mode" allows to choose between the options :
//
// mode :  1 --> The nuclear mass is returned in GeV/c^2
//        -1 --> The nuclear mass is returned in amu
//         2 --> The total binding energy is returned in MeV
//        -2 --> The total binding energy is returned in amu
//         3 --> The binding energy per nucleon is returned in MeV
//        -3 --> The binding energy per nucleon is returned in amu
//
// Here "amu" stands for unified atomic mass unit. 
//
// The default is mode=1.

Definition at line 8060 of file NcAstrolab.cxx.

GetPhysicalDistance()

Double_t NcAstrolab::GetPhysicalDistance	(	Double_t	z,
		TString	u = "Mpc",
		Int_t	t = 1 ) const

// Provide the physical distance of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The physical distance reflects the distance that one would measure
// with a ruler at a specific time (see below).
//
// Note that the physical distance is also called "proper distance".
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The input argument "u" allows specification of the required distance units,
// with the following options:
//
// u = "Gpc" (distance in Giga parsec)
//     "Mpc" (distance in Mega parsec)
//     "pc"  (distance in parsec)
//     "ly"  (distance in light years)
//     "km"  (distance in kilometers)
//     "m"   (distance in meters)
//     "cm"  (distance in centimeters)
//
// The argument "t" allows to specify the time of the distance determination.
//
// t = 0 --> The distance is determined at the time of emission of the signal
//     1 --> The distance is determined at the time of observation of the signal
//
// The default values are u="Mpc" and t=1 for backward compatibility.
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 7732 of file NcAstrolab.cxx.

GetPhysicalParameter()

Double_t NcAstrolab::GetPhysicalParameter

(

TString

name

)

const

// Provide the (modified) value of a (astro)physical parameter.
//
// The parameter is specified via the input argument "name".
// Please refer to the docs of memberfunction SetPhysicalParameter()
// to see a list of currently supported parameters.
//
// In addition to the standard parameters, also the values of some
// useful derived parameters c.q. conversion constants may be obtained.
// These additional values are :
//
// Hbar   = The value of hbar in MeV s
// Hbarc  = The value of the conversion constant hbar*c in MeV fm 
// Hbarc2 = The value of the conversion constant (hbar*c)^2 in GeV^2 barn
// Mnucl  = The nucleon mass (=average of proton and neutron mass) in MeV/c^2
// Sin2w  = The sin^2 of the Weinberg angle
// Jy     = Flux density of 1 Jansky (1e-23 erg s^-1 cm^-2 Hz^-1)
// Erg    = The equivalent of 1 erg in GeV

Definition at line 7654 of file NcAstrolab.cxx.

GetPositionScramble()

Int_t NcAstrolab::GetPositionScramble	(	Double_t *	dmin = 0,
		Double_t *	dmax = 0,
		TF1 *	df = 0,
		Double_t *	thmin = 0,
		Double_t *	thmax = 0,
		TF1 *	thf = 0,
		Double_t *	phimin = 0,
		Double_t *	phimax = 0,
		TF1 *	phif = 0 )

// Provide parameters which are used for position scrambling of the measurements.
//
// The standard returned value is the "position scrambling mode". 
// The memberfunction arguments provide the possibility of retrieving
// various optional values. The corresponding parameters are :
//
// dmin   : Minimal value for scrambling angular difference (in degrees) or vector length 
// dmax   : Maximal value for scrambling angular difference (in degrees) or vector length
// df     : Randomisation function for angular difference (or vector length) scrambling
// thmin  : Minimal value (in degrees) for scrambling local theta coordinate
// thmax  : Maximal value (in degrees) for scrambling local theta coordinate
// thf    : Randomisation function for local theta coordinate scrambling
// phimin : Minimal value (in degrees) for scrambling local phi coordinate
// phimax : Maximal value (in degrees) for scrambling local phi coordinate
// phif   : Randomisation function for local phi coordinate scrambling
//
// For a detailed description of the various time scrambling parameters
// please refer to the docs of the memberfunction SetPositionScramble.
//
// Note : In case an argument is entered as zero, the corresponding parameter
//        value will not be provided.
//
// Default argument values are dmin=0, dmax=0, df=0, thmin=0, thmax=0, thf=0, phimin=0, phimax=0 and phif=0.  
//
// Invokation example :
// --------------------
// NcAstrolab lab;
// Int_t mode;
// Double_t dlow,dup;
// TF1 func;
// mode=lab.GetPositionScramble(&dlow,&dup,&func);

Definition at line 6074 of file NcAstrolab.cxx.

GetProperDistance()

Double_t NcAstrolab::GetProperDistance	(	Double_t	z,
		TString	u = "Mpc",
		Int_t	t = 1 ) const

// Provide the proper distance of an object observed with redshift z
// for a flat Friedmann-Lemaitre universe.
//
// The proper distance reflects the distance that one would measure
// with a ruler at a specific time (see below).
//
// Note that the proper distance is also called "physical distance".
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/Home/lectures/thelargescaleuniverse
//
// The input argument "u" allows specification of the required distance units,
// with the following options:
//
// u = "Gpc" (distance in Giga parsec)
//     "Mpc" (distance in Mega parsec)
//     "pc"  (distance in parsec)
//     "ly"  (distance in light years)
//     "km"  (distance in kilometers)
//     "m"   (distance in meters)
//     "cm"  (distance in centimeters)
//
// The argument "t" allows to specify the time of the distance determination.
//
// t = 0 --> The distance is determined at the time of emission of the signal
//     1 --> The distance is determined at the time of observation of the signal
//
// The default values are u="Mpc" and t=1 for backward compatibility.
// In case "u" is incorrectly specified, the value 0 will be returned.

Definition at line 7799 of file NcAstrolab.cxx.

GetRadiationLength()

Double_t NcAstrolab::GetRadiationLength	(	Double_t	Z,
		Double_t	A,
		Double_t	rho = -1 ) const

// Provide the radiation length of a medium consisting of (averaged) nuclei (Z,A).
// The radiation length is returned in g/cm^2, #nucleons/cm^2 or cm, depending on
// the value of "rho" (see below)
//
// The radition length (X0) is the mean distance over which the energy of a high-energy electron
// is reduced by a factor 1/e due to bremmstrahlung.
// Alternatively, it is also 7/9 times the mean free path of a high-energy photon before
// pair production occurs.
//
// The following approximation was obtained from the Particle Data Group (https://pdg.lbl.gov)
//
// X0=716.4*A/[Z(Z+1)(Ln(287/sqrt(Z))] g/cm^2
//
// Input arguments :
// -----------------
// Z   : The (averaged) atomic number (=number of protons) of the nucleus 
// A   : The (averaged) mass number (=number of nucleons) of the nucleus
// rho : <0 --> [X0]=g/cm^2
//       =0 --> [X0]=#nucleons/cm^2
//       >0 --> rho=density of the medium in g/cm^3 and [X0]=cm
//
// The default value is rho=-1.
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8186 of file NcAstrolab.cxx.

GetRandomiser()

NcRandom * NcAstrolab::GetRandomiser	(	Int_t &	iseed,
		Int_t &	cnt1,
		Int_t &	cnt2 ) const

// Provide the current "iseed", "cnt1" and "cnt2" parameters of the internal NcRandom randomiser.
// For detailed information about these parameters please refer to the docs of NcRandom. 
// The return argument is the pointer to the internal NcRandom object.
// In case no internal randomiser was defined, a pointer value 0 will be returned and
// the parameters will be set to iseed=-1, cnt1=-1 and cnt2=-1.

Definition at line 1149 of file NcAstrolab.cxx.

GetSeparation() [1/2]

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 = 0, Double_t * difphi = 0 )

protected

// Internal memberfunction to provide space and time separation between the i-th and j-th stored signal.
// This memberfunction serves the public GetSeparation(), MatchSignals() and MatchBurstData() facilities.
//
// i > 0 : Indicates a reference signal stored at index i (i=1 is the first)
// i < 0 : Indicates a measurement stored at index abs(i) (i=-1 is the first)
// j > 0 : Indicates a reference signal stored at index j (j=1 is the first)
// j < 0 : Indicates a measurement stored at index abs(j) (j=-1 is the first)
//
// In case both signals were stored as a measurement (or reference signal),
// then the signal indicated via "i" will be regarded as a reference signal,
// and the signal indicated via "j" will be regarded as a measurement.
// 
// The return value of this memberfunction provides the positional angular
// separation, whereas the output argument "dt" provides the time difference.
// The optional output arguments "diftheta" and "difphi" provide the difference
// in theta and phi, respectively, between the i-th and the j-th stored signal,
// in which the reference signal is used as the origin.
// These optional values may be used for local zenith or azimuth band investigations.
// The units of "diftheta" and "difphi" are determined by the "au" input argument (see below).
//
// In case of inconsistent input, the return value and the optional "diftheta" and "difphi"
// will have the unphysical value of -999, whereas "dt" will be set to 1e30.
//
// The units of the angular separation can be specified via the "au" input argument, where
//
// au = "rad" --> Angular separation in (fractional) radians
//      "deg" --> Angular separation in (fractional) degrees
//
// The units of the time difference can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
//
// For the time difference the reference signal is used as the standard.
// This means that in case of a positive time difference, the other signal
// occurred later than the reference one.
//
// In case scrambling has been activated, the results will be scrambled accordingly.
// The argument "bkgpatch" indicates the background patch number for the creation of
// the corresponding off-source (background) data, where bkgpatch=0 means on-source data.
// Negative values for the time and position scrambling parameters are taken into account
// only for the creation of off-source (background) data, see MatchBurstData().
// For details see the docs of SetTimeScramble() and SetPositionScramble().
//
// The default values are diftheta=0 and difphi=0.

Definition at line 4996 of file NcAstrolab.cxx.

GetSeparation() [2/2]

Double_t NcAstrolab::GetSeparation	(	TString	name1,
		TString	name2,
		TString	au,
		Double_t *	dt = 0,
		TString	tu = "s",
		Int_t	mode = 1,
		Double_t *	diftheta = 0,
		Double_t *	difphi = 0 )

// Provide space (and optional time) separation between the signals stored with "name1" and "name2".
//
// Note :
// ------
// In case both signals were stored as a measurement (or reference signal),
// then the signal indicated via "name1" will be regarded as a reference signal,
// and the signal indicated via "name2" will be regarded as a measurement.
//
// In case a name specifies a solar system object supported by SetSolarSystem(),
// which was not yet stored, the corresponding reference signal will be created and stored.
// In case the solar system object was already stored as a reference object, its position and timestamp
// will be updated according to the timestamp of the measurement to which it will be compared.
// In case the solar system object was stored as a measurement, its position and timestamp are not modfified.
// All geocentric name specifications for solar system objects as indicated in the
// docs of NcTimestamp::Almanac() are supported.
// 
// The return value of this memberfunction provides the positional angular
// separation, whereas the optional output argument "dt" provides the time difference.
// The optional output arguments "diftheta" and "difphi" provide the difference
// in theta and phi, respectively, between the signals, in which the reference signal is used as the origin.  
// The units of "diftheta" and "difphi" are determined by the "au" input argument (see below).
//
// In case of inconsistent input, the return value and the optional "diftheta" and "difphi"
// will have the unphysical value of -999, whereas "dt" will be set to 1e30.
//
// The units of the angular separation can be specified via the "au" input argument, where
//
// au = "rad" --> Angular separation in (fractional) radians
//      "deg" --> Angular separation in (fractional) degrees
//
// The units of the time difference can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
//
// For the time difference the reference signal is used as the standard.
// This means that in case of a positive time difference, the other signal
// occurred later than the reference one.
//
// Note : In case scrambling has been activated, the results will be scrambled accordingly,
//        but only in case of positive values of the time c.q. position scrambling modes.
//        For details see the docs of SetTimeScramble() and SetPositionScramble().
//
// The default values are dt=0, tu="s", mode=1, diftheta=0 and difphi=0.

Definition at line 4907 of file NcAstrolab.cxx.

GetShieldingThickness() [1/2]

Double_t NcAstrolab::GetShieldingThickness	(	Double_t	prob,
		Double_t	lambda ) const

// Provide the shielding thickness "x" to obtain the specified survival probability
// for a high-energy particle.
// The calculated thickness is returned in the same units as the provided "lambda".
//
// Input arguments :
// -----------------
// prob   : The requested survival probability
// lambda : The mean free path of the particle in the medium
//
// The formula used is : x=-lambda*Ln(prob).
//
// So, when the specified probability is 1/e, the shielding thickness x=lambda.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// Note :
// ------
// The shielding thickness for a high-energy photon to undergo pair production
// may be obtained from the corresponding radiation length X0 by using the fact
// that lambda=X0*9/7.
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8454 of file NcAstrolab.cxx.

GetShieldingThickness() [2/2]

Double_t NcAstrolab::GetShieldingThickness	(	Double_t	prob,
		Double_t	sigma,
		Double_t	rho,
		Int_t	mode ) const

// Provide the shielding thickness "x" to obtain the specified survival probability
// for a high-energy particle.
// The input parameter "mode" dictates the units of "rho" and the returned value of "x" (see below).
//
// Input arguments :
// -----------------
// prob  : The requested survival probability
// sigma : The interaction cross section in barn (1 barn=1e-24 cm^2)
// rho   : The density of the medium (see below)
// mode  : 0 --> rho=#particles/cm^3 and [x]=cm
//         1 --> rho=#particles/cm^3 and [x]=#particles/cm^2
//         2 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=cm
//         3 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=g/cm^2
//         4 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=#nucleons/cm^2
//
// The formula used is : x=-lambda*Ln(prob),
// where lambda is the corresponding mean free path.
//
// So, when the specified probability is 1/e, the shielding thickness x=lambda.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8493 of file NcAstrolab.cxx.

GetSignal() [1/7]

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 = "T",
		Int_t	type = 0 )

// Provide celestial position data (d,a,b) of the signal specified by "jref" and "type" at the specific timestamp ts.
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the coordinate "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation may have been specified and retrieved here.
// In addition also a pointer to the stored signal object is provided.
// In case no stored signal was available or one of the input arguments was
// invalid, the returned pointer will be 0.
//
// Note : In case the time difference between the stored signal and the specified
//        timestamp is larger than the maximum allowed (see memberfunction SetMaxDt),
//        the d, a and b coordinates are set to 0 and also the returned pointer will be 0.
//
// The input parameters "jref" and "type" allow to access measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Access to a signal at the j-th position (j=1 is first)
//        0 --> Access to the first measurement (only kept for backward compatibility)
//
// type = 0 --> The requested data is a reference signal
//        1 --> The requested data is a measured signal
//
// The user is advised not to use the obsolete "jref=0" functionality anymore.
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal" ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr" ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc" ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : angle provided in radians
//          "deg" : angle provided in degrees
//          "dms" : angle provided in dddmmss.sss
//          "hms" : angle provided in hhmmss.sss
//          "hrs" : angle provided in fractional hours
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to select either "mean", "true" or "epoch"
// values in the case of equatorial (a,b) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The correction methods used are the new IAU 2000 ones as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
//
// Default values are mode="T" and type=0.
//
// Note : In case ts=0 the current timestamp of the lab will be taken.

Definition at line 2656 of file NcAstrolab.cxx.

GetSignal() [2/7]

NcSignal * NcAstrolab::GetSignal	(	Double_t &	d,
		Double_t &	a,
		TString	au,
		Double_t &	b,
		TString	bu,
		TString	frame,
		NcTimestamp *	ts,
		TString	name,
		TString	mode = "T",
		Int_t	type = 0 )

// Provide celestial position data (d,a,b) of the signal specified by "name" and "type" at the specific timestamp ts.
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the coordinate "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation may have been specified and retrieved here.
// In addition also a pointer to the stored signal object is provided.
// In case no stored signal was available or one of the input arguments was
// invalid, the returned pointer will be 0.
//
// The input parameter "type" allows to access measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// type = 0 --> The requested data is a reference signal
//        1 --> The requested data is a measured signal
//
// Notes :
// -------
// 1) In case the name specifies a solar system object which was not yet stored according to "type",
//    the corresponding signal will be created and stored with the specified timestamp.
//    All geocentric name specifications for solar system objects as indicated in the
//    docs of NcTimestamp::Almanac() are supported.
// 2) In case the time difference between the stored signal and the specified
//    timestamp is larger than the maximum allowed (see memberfunction SetMaxDt),
//    the d, a and b coordinates are set to 0 and also the returned pointer will be 0.
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal" ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr" ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc" ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : angle provided in radians
//          "deg" : angle provided in degrees
//          "dms" : angle provided in dddmmss.sss
//          "hms" : angle provided in hhmmss.sss
//          "hrs" : angle provided in fractional hours
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to select either "mean", "true" or "epoch"
// values in the case of equatorial (a,b) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The correction methods used are the new IAU 2000 ones as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
//
// Default values are mode="T" and type=0.
//
// Note : In case ts=0 the current timestamp of the lab will be taken.

Definition at line 2789 of file NcAstrolab.cxx.

GetSignal() [3/7]

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 = 0 )

// Provide celestial position data (d,a,b) of the signal specified by "jref" and "type" at the specified epoch.
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the coordinate "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation may have been specified and retrieved here.
// In addition also a pointer to the stored signal object is provided.
// In case no stored signal was available or one of the input arguments was
// invalid, the returned pointer will be 0.
//
// Note : In case the time difference between the stored signal and the specified
//        timestamp is larger than the maximum allowed (see memberfunction SetMaxDt),
//        the d, a and b coordinates are set to 0 and also the returned pointer will be 0.
//
// The input parameters "jref" and "type" allow to access measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Access to a signal at the j-th position (j=1 is first)
//        0 --> Access to the first measurement (only kept for backward compatibility)
//
// type = 0 --> The requested data is a reference signal
//        1 --> The requested data is a measured signal
//
// The user is advised not to use the obsolete "jref=0" functionality anymore.
//
// Default values are jref=0 and type=0.
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal" ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr" ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc" ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : angle provided in radians
//          "deg" : angle provided in degrees
//          "dms" : angle provided in dddmmss.sss
//          "hms" : angle provided in hhmmss.sss
//          "hrs" : angle provided in fractional hours
//
// The time of the observation is specified by the following epoch input arguments :
//
//  s = "B" --> Besselian reference epoch.
//      "J" --> Julian reference epoch.
//  e : (Fractional) epoch to specify the timestamp of the observation (e.g. 1952.004353 or 2003.80953216)
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" and "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to select either "mean", "true" or "epoch"
// values in the case of equatorial (a,b) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The correction methods used are the new IAU 2000 ones as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.

Definition at line 2872 of file NcAstrolab.cxx.

GetSignal() [4/7]

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 = 0 )

// Provide celestial position data (d,a,b) of the signal specified by "name" and "type" at the specified epoch.
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the coordinate "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation may have been specified and retrieved here.
// In addition also a pointer to the stored signal object is provided.
// In case no stored signal was available or one of the input arguments was
// invalid, the returned pointer will be 0.
//
// The input parameter "type" allows to access measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// type = 0 --> The requested data is a reference signal
//        1 --> The requested data is a measured signal
//
// Default value is type=0.
//
// Notes :
// -------
// 1) In case the name specifies a solar system object which was not yet stored according to "type",
//    the corresponding signal will be created and stored with the specified epoch as timestamp.
//    All geocentric name specifications for solar system objects as indicated in the
//    docs of NcTimestamp::Almanac() are supported.
// 2) In case the time difference between the stored signal and the specified
//    timestamp is larger than the maximum allowed (see memberfunction SetMaxDt),
//    the d, a and b coordinates are set to 0 and also the returned pointer will be 0.
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal" ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr" ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc" ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : angle provided in radians
//          "deg" : angle provided in degrees
//          "dms" : angle provided in dddmmss.sss
//          "hms" : angle provided in hhmmss.sss
//          "hrs" : angle provided in fractional hours
//
// The time of the observation is specified by the following epoch input arguments :
//
//  s = "B" --> Besselian reference epoch.
//      "J" --> Julian reference epoch.
//  e : (Fractional) epoch to specify the timestamp of the observation (e.g. 1952.004353 or 2003.80953216)
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to select either "mean", "true" or "epoch"
// values in the case of equatorial (a,b) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The correction methods used are the new IAU 2000 ones as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.

Definition at line 2962 of file NcAstrolab.cxx.

GetSignal() [5/7]

NcSignal * NcAstrolab::GetSignal	(	Int_t	jref = 0,
		Int_t	type = 0 )

// Provide the pointer to a stored signal object.
//
// The input parameters "jref" and "type" allow to access either measured of so-called "reference" signals.
// The reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Access to the signal at the j-th position (j=1 is first)
//
// type = 0 --> Provide the corresponding reference signal
//        1 --> Provide the corresponding measurement
//
// Note : jref=0 is an obsolete way to access the first measurement.
//        The user is advised not to use this obsolete "jref=0" method anymore,
//        but it is still supported for backward compatibility.
//
// Default values are jref=0 and type=0 for backward compatibility.

Definition at line 3051 of file NcAstrolab.cxx.

GetSignal() [6/7]

NcSignal * NcAstrolab::GetSignal ( Nc3Vector & r, TString frame, TString mode, NcTimestamp * ts, Int_t jref, Int_t type )

protected

// Internal memberfunction to provide the frame specific coordinates of a signal at the specified timestamp ts.
// The coordinates are returned via the vector argument "r".
// In addition also a pointer to the stored signal object is provided.
// In case no stored signal was available or one of the input arguments was
// invalid, the returned pointer will be 0.
//
// Note : In case the time difference between the stored signal and the specified
//        timestamp is larger than the maximum allowed (see memberfunction SetMaxDt),
//        the vector "r" is set to 0 and also the returned pointer will be 0.
//
// The input parameter "frame" specifies the frame to which the components of r refer.
// The various conventions are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d),
//                    where the "sph" components of r correspond to theta=(pi/2)-d and phi=a.
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b),
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, where the "sph"
//                    components of r correspond to theta=zenith angle and phi=pi-azimuth.
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b),
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "loc" ==> Local coordinates at the NcAstrolab location, where the "sph"
//                    components of r correspond to the usual theta and phi angles.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" specifies either "mean", "true" or "epoch" values for the equatorial (a,d) coordinates.
//
// mode = "M" --> Provided coordinates are the mean values 
//        "T" --> Provided coordinates are the true values 
//        "B" --> Provides Besselian (B1950) reference epoch coordinates 
//        "J" --> Provides Julian (J2000) reference epoch coordinates 
//
// The input parameters "jref" and "type" allow to access measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Access to a signal at the j-th position (j=1 is first)
//        0 --> Access to the first measurement (only kept for backward compatibility)
//
// type = 0 --> The requested data is a reference signal
//        1 --> The requested data is a measured signal
//
// The user is advised not to use the obsolete "jref=0" functionality anymore.
//
// Note : In case ts=0 the current timestamp of the lab will be taken.

Definition at line 2325 of file NcAstrolab.cxx.

GetSignal() [7/7]

NcSignal * NcAstrolab::GetSignal	(	TString	name,
		Int_t	type = 0,
		NcTimestamp *	ts = 0 )

// Provide the pointer to the stored signal object with the specified name and type.
//
// type = 0 --> Provide the corresponding reference signal
//        1 --> Provide the corresponding measurement
//
//
// Note : In case the name specifies a solar system object which was not yet stored,
//        the corresponding signal will be created according to "type" and the provided
//        timestamp "ts".
//        In case ts=0, the current timestamp of this NcAstrolab instance will be used.
//        All geocentric name specifications for solar system objects as indicated in the
//        docs of NcTimestamp::Almanac() are supported.
//
// The default values are type=0 and ts=0 for backward compatibility.

Definition at line 3097 of file NcAstrolab.cxx.

GetSignalIndex() [1/2]

Int_t NcAstrolab::GetSignalIndex	(	NcSignal *	s,
		Int_t	type )

// Provide storage index of the specified signal.
//
// type = 0 --> Provide the index of a reference signal
//      = 1 --> Provide the index of a measured signal
//
// In case no matching signal is found, the value -1 is returned.

Definition at line 3432 of file NcAstrolab.cxx.

GetSignalIndex() [2/2]

Int_t NcAstrolab::GetSignalIndex	(	TString	name,
		Int_t	type = 0 )

// Provide storage index of the signal with the specified name.
//
// type = 0 --> Provide the index of a reference signal
//      = 1 --> Provide the index of a measured signal
//
// In case name="" or no signal with the specified name was found, the value -1 is returned.
//
// The default value is type=0 for backward compatibility.

Definition at line 3393 of file NcAstrolab.cxx.

GetSignalRatePDF()

TF1 NcAstrolab::GetSignalRatePDF	(	Double_t	Non,
		Double_t	Ton,
		Double_t	Noff,
		Double_t	Toff,
		Double_t	Ra = 1,
		Double_t	Re = 1,
		Double_t	smax = -1,
		Double_t	bmax = -1,
		Double_t	prec = 709 )

// Provide the posterior Bayesian PDF for a source signal rate "s"
// given the specified "on source" and "off source" observations.
//
// Details of the method can be found in the publication Astrop. Phys. 50-52 (2013) 57.
// The actual code is implemented in the internal memberfunction GetSignalRateProb().
//
// The input arguments :
// ---------------------
// Non  : The total number of observed "on source" (signal+background) events.
// Ton  : The "on source" exposure time in seconds.
// Noff : The number of observed "off source" (background) events.
// Toff : The "off source" exposure time in seconds.
// Ra   : The ratio (on source area)/(off source area)
// Re   : The ratio (on source detection efficiency)/(off source detection efficiency)
// smax : The maximimal signal event rate in Hz.
//        If smax<0 this parameter is automatically set to 100*Non/Ton
//        to obtain good prior coverage as indicated below.
// bmax : The maximimal background event rate in Hz.
//        If bmax<0 this parameter is automatically set to 1000*Noff/Toff
//        to obtain good prior coverage as indicated below.
// prec : Cut off value to limit exponential expressions to exp(|prec|) or exp(-|prec|)
//        to prevent overflow or underflow.
//
// Default values : Ra=1, Re=1, smax=-1, bmax=-1 and prec=709.
//
// The returned PDF is p(s|Non,Ton,Noff,Toff,I), where "I" indicates the prior information.
//
// The priors p(s|I) and p(b|I) for the signal and background rates, respectively, have been taken
// as uniform priors within the ranges [0,smax] and [0,bmax].
// The parameters "smax" and "bmax" may be provided as results from previous studies, reflecting
// prior information to be used in the Bayesian evaluation.
// If they are not provided (or as negative values) the parameters "smax" and "bmax" are set
// automatically to provide good prior coverage.

Definition at line 10095 of file NcAstrolab.cxx.

GetSignalRateProb()

Double_t NcAstrolab::GetSignalRateProb ( Double_t * vars, Double_t * pars )

protected

// Provide the posterior Bayesian probability for a certain source signal rate "s"
// given some specified "on source" and "off source" observations.
//
// *** This is an internal interface memberfunction used by GetSignalRatePDF() ***
//
// Details of the method can be found in the publication Astrop. Phys. 50-52 (2013) 57.
// This implementation is based on the original code of Lionel Brayeur and Krijn de Vries.
//
// Note : It is essential that the provided Non and Noff data correspond to equal areas and
//        detection efficiencies.
//        See the memberfunction GetSignalRatePDF() as an example how to handle this.
//
// The input arguments :
// ---------------------
// vars[0] (s)    : The signal rate (in Hz) for which the posterior probability will be evaluated.
// pars[0] (Non)  : The total number of observed "on source" (signal+background) events.
// pars[1] (Ton)  : The "on source" exposure time in seconds.
// pars[2] (Noff) : The number of observed "off source" (background) events.
// pars[3] (Toff) : The "off source" exposure time in seconds.
// pars[4] (smax) : The maximimal signal event rate in Hz.
//                  If smax<0 this parameter is automatically set to 100*Non/Ton
//                  to obtain good prior coverage as indicated below.
// pars[5] (bmax) : The maximimal background event rate in Hz.
//                  If bmax<0 this parameter is automatically set to 100*Noff/Toff
//                  to obtain good prior coverage as indicated below.
// pars[6] (prec) : Cut off value to limit exponential expressions to exp(|prec|) or exp(-|prec|) 
//                  to prevent overflow or underflow.
//
// Default values : smax=-1, bmax=-1 and prec=709.
//
// The returned value is p(s|Non,Ton,Noff,Toff,I), where "I" indicates the prior information.
//
// The priors p(s|I) and p(b|I) for the signal and background rates, respectively, have been taken
// as uniform priors within the ranges [0,smax] and [0,bmax].
// The parameters "smax" and "bmax" may be provided as results from previous studies, reflecting
// prior information to be used in the Bayesian evaluation.
// If they are not provided (or as negative values) the parameters "smax" and "bmax" are set
// automatically to provide good prior coverage.

Definition at line 9933 of file NcAstrolab.cxx.

GetSolidAngle()

Double_t NcAstrolab::GetSolidAngle	(	Double_t	thetamin,
		Double_t	thetamax,
		TString	tu,
		Double_t	phimin,
		Double_t	phimax,
		TString	pu ) const

// Provide the solid angle (in sr) between the specified boundaries.
//
// Input arguments :
// -----------------
// thetamin : The minimum value of the polar angle theta
// thetamax : The maximum value of the polar angle theta
// tu       : The units in which theta is provided (see memberfunction ConvertAngle)
// phimin   : The minimum value of the azimuthal angle phi
// phimax   : The maximum of the azimuthal angle phi
// pu       : The units in which phi is provided (see memberfunction ConvertAngle)

Definition at line 4586 of file NcAstrolab.cxx.

GetSourceAttributes()

Double_t NcAstrolab::GetSourceAttributes	(	NcSignal *	s,
		Float_t *	z = 0,
		Float_t *	T90 = 0 )

// Provide various attributes for an astrophysical object that is stored with the signal pointer "s".
// The signal pointer "s" can be obtained via the memberfunctions SetSignal() or GetSignal().
// 
// Arguments :
// -----------
// s        : Pointer to the signal with which the astrophysical object is stored
// z        : Optional pointer argument to provide the redshift value
// T90      : Optional pointer argunent to provide the T90 duration in seconds in case of a transient object
//
// The return argument represents the 1-sigma position uncertainty in degrees.
// In case an unphysical value is provided, this means the value is not known.
//
// The default values are z=0 and T90=0, which implies that by default only
// the 1-sigma position uncertainty is provided.

Definition at line 2220 of file NcAstrolab.cxx.

GetSurvivalProbability() [1/2]

Double_t NcAstrolab::GetSurvivalProbability	(	Double_t	x,
		Double_t	lambda ) const

// Provide the survival probability of a high-energy particle traveling
// a distance "x" through a certain medium.
//
// For a mono-energetic beam of identical particles, this probability
// also represents the beam attenuation factor.
//
// Input arguments :
// -----------------
// x      : The distance traveled by the particle inside the medium
// lambda : The mean free path of the particle in the medium
//
// The formula used is : prob=exp(-x/lambda).
//
// So, when x=lambda, the survial probability is 1/e.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// Notes :
// -------
// 1) "x" and "lambda" have to be specified in the same units.
// 2) The probability for a high-energy photon to survive pair production
//    may be obtained from the corresponding radiation length X0
//    by using the fact that lambda=X0*9/7.
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8369 of file NcAstrolab.cxx.

GetSurvivalProbability() [2/2]

Double_t NcAstrolab::GetSurvivalProbability	(	Double_t	x,
		Double_t	sigma,
		Double_t	rho,
		Int_t	mode ) const

// Provide the survival probability of a high-energy particle traveling
// a distance "x" through a certain medium.
// The input parameter "mode" dictates the units of "x" and "rho" (see below).
//
// For a mono-energetic beam of identical particles, this probability
// also represents the beam attenuation factor.
//
// Input arguments :
// -----------------
// x     : The distance traveled by the particle inside the medium (see below)
// sigma : The interaction cross section in barn (1 barn=1e-24 cm^2)
// rho   : The density of the medium (see below)
// mode  : 0 --> rho=#particles/cm^3 and [x]=cm
//         1 --> rho=#particles/cm^3 and [x]=#particles/cm^2
//         2 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=cm
//         3 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=g/cm^2
//         4 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=#nucleons/cm^2
//
// The formula used is : prob=exp(-x/lambda),
// where lambda is the corresponding mean free path.
//
// So, when x=lambda, the survial probability is 1/e.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8411 of file NcAstrolab.cxx.

GetTargetThickness() [1/2]

Double_t NcAstrolab::GetTargetThickness	(	Double_t	prob,
		Double_t	lambda ) const

// Provide the target thickness "x" to obtain the specified interaction probability
// for a high-energy particle.
// The calculated thickness is returned in the same units as the provided "lambda".
//
// Input arguments :
// -----------------
// prob   : The requested interaction probability
// lambda : The mean free path of the particle in the medium
//
// The formula used is : x=-lambda*Ln(1-prob).
//
// So, when the specified probability is (1-1/e), the shielding thickness x=lambda.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// Note :
// ------
// The target thickness for a high-energy photon to undergo pair production
// may be obtained from the corresponding radiation length X0 by using the fact
// that lambda=X0*9/7.
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8535 of file NcAstrolab.cxx.

GetTargetThickness() [2/2]

Double_t NcAstrolab::GetTargetThickness	(	Double_t	prob,
		Double_t	sigma,
		Double_t	rho,
		Int_t	mode ) const

// Provide the target thickness "x" to obtain the specified interaction probability
// for a high-energy particle.
// The input parameter "mode" dictates the units of "rho" and the returned value of "x" (see below).
//
// Input arguments :
// -----------------
// prob  : The requested interaction probability
// sigma : The interaction cross section in barn (1 barn=1e-24 cm^2)
// rho   : The density of the medium (see below)
// mode  : 0 --> rho=#particles/cm^3 and [x]=cm
//         1 --> rho=#particles/cm^3 and [x]=#particles/cm^2
//         2 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=cm
//         3 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=g/cm^2
//         4 --> Atomic c.q. nuclear medium with [rho]=g/cm^3 and [x]=#nucleons/cm^2
//
// The formula used is : x=-lambda*Ln(1-prob),
// where lambda is the corresponding mean free path.
//
// So, when the specified probability is (1-1/e), the shielding thickness x=lambda.
//
// For details please refer to the slides of my lectures :
// https://sites.google.com/site/nickveweb/lectures/scatteringanddecayprocesses
//
// In case of inconsistent input the unphysical value -1 will be returned.

Definition at line 8573 of file NcAstrolab.cxx.

GetTimeScramble()

Int_t NcAstrolab::GetTimeScramble	(	Double_t *	tmin = 0,
		Double_t *	tmax = 0,
		TF1 *	frndm = 0 )

// Provide parameters which are used for time scrambling of the measurements.
//
// The standard returned value is the "time scrambling mode". 
// The memberfunction arguments provide the possibility of retrieving
// various optional values. The corresponding parameters are :
//
// tmin  : Minimal value (in seconds) for time scrambling
// tmax  : Maximal value (in seconds) for time scrambling
// frndm : Randomising function to perform the scrambling
//
// For a detailed description of the various time scrambling parameters
// please refer to the docs of the memberfunction SetTimeScramble.
//
// Note : In case an argument is entered as zero, the corresponding parameter
//        value will not be provided.
//
// Default argument values are tmin=0, tmax=0 and frndm=0.  
//
// Invokation example :
// --------------------
// NcAstrolab lab;
// Int_t mode;
// Double_t tlow,tup;
// TF1 func;
// mode=lab.GetTimeScramble(&tlow,&tup,&func);

Definition at line 5907 of file NcAstrolab.cxx.

GetUpperLimit() [1/2]

Double_t NcAstrolab::GetUpperLimit	(	TF1	pdf,
		Double_t	p )

// Provide the Bayesian "p%" upperlimit for the specified PDF.
//
// The specified PDF does not need to be normalised.
//
// Note : The result is provided for the current range (see TF1::SetRange) of the PDF,
//        which is reflected in e.g. TF1::Draw().
//        For a good interpretation of the returned value, the user has to make sure
//        that the range covers the full PDF.
//        This range is automatically set if the PDF is the result of the
//        memberfunctions GetBackgroundRatePDF() or GetSignalRatePDF(). 
//
// In case of inconsistent data 0 is returned.  

Definition at line 10168 of file NcAstrolab.cxx.

GetUpperLimit() [2/2]

Double_t NcAstrolab::GetUpperLimit	(	TH1 *	pdf,
		Double_t	p )

// Provide the Bayesian "p%" upperlimit for the specified histogram.
//
// The specified histogram does not need to be normalised.
//
// In case of inconsistent data 0 is returned.  

Definition at line 10202 of file NcAstrolab.cxx.

HelioToGeocentric()

void NcAstrolab::HelioToGeocentric	(	Double_t &	R,
		Double_t &	B,
		Double_t &	L,
		NcTimestamp *	ts,
		TString	Bu = "deg",
		TString	Lu = "deg" )

// Convert Heliocentric ecliptic coordinates into Geocentric ones at the provided timestamp.
// The algorithm used here is the one outlined in Ch. 33 of the book by Jean Meeus,
// "Astronomical Algorithms" (2nd edition of August 2009).
// In view of the accuracy of the current algorithm, the effects of light-time
// and aberration are not taken into account here.
//
// Input arguments :
// -----------------
// R  : Heliocentric distance of the object in Astronomical Units (AU)
// B  : Heliocentric ecliptic latitude
// L  : Heliocentric ecliptic longitude
// ts : Timestamp of the (R,B,L) observation (0=The current NcAstrolab timestamp)
// Bu : Angular units of B (see below)
// Lu : Angular units of L (see below)
//
// Angular units indicator :
// -------------------------
// "rad" : input angle provided in radians
// "deg" : input angle provided in degrees
// "dms" : input angle provided in dddmmss.sss
// "hms" : input angle provided in hhmmss.sss
// "hrs" : input angle provided in fractional hours
//
// After the conversion, R, B and L will be the Geocentric values.
//
// Note : For objects far outside the Solar System, the Geocentric and Heliocentric
//        coordinates are basically identical.
//
// The default values are Bu="deg" and Lu="deg".

Definition at line 2578 of file NcAstrolab.cxx.

InfoPanel()

void NcAstrolab::InfoPanel ( TGCompositeFrame * frame )

protectedvirtual

// The Information panel.

Definition at line 18079 of file NcAstrolab.cxx.

InitBurstHistograms()

void NcAstrolab::InitBurstHistograms ( Int_t mode )

protected

// Internal memberfunction to initialize the histograms for transient burst analyses.
//
// mode : 0 --> Invoked from GenBurstSignals()
//        1 --> Invoked from MatchBurstData()
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 15696 of file NcAstrolab.cxx.

InitDataNames()

void NcAstrolab::InitDataNames	(	Int_t	dir,
		TString	frame,
		TString	mode = "J" )

// Initialisation of the correspondence table between physical observables
// and their names in a ROOT input Tree.
// The actual correspondence settings are performed by invokation of SetDataNames().
// 
// Input arguments :
// -----------------
// dir   = >0 ==> Coordinates indicate the arrival direction
//         <0 ==> Coordinates indicate the direction of motion
//
// frame = "equ" ==> Equatorial coordinates with right ascension and declination.
//         "gal" ==> Galactic coordinates with longitude and latitude.
//         "ecl" ==> Geocentric ecliptic coordinates with longitude and latitude.
//         "hor" ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle and zenith angle.
//         "icr" ==> ICRS coordinates with longitude and latitude.
//         "loc" ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta and phi.
//
// mode  = "M" ==> Equatorial coordinates are the mean values 
//         "T" ==> Equatorial coordinates are the true values
//         "B" ==> Besselian (B1950) reference epoch equatorial coordinates 
//         "J" ==> Julian (J2000) reference epoch equatorial coordinates 
//
// The default value is mode="J".

Definition at line 11021 of file NcAstrolab.cxx.

KolmogorovTest()

Double_t NcAstrolab::KolmogorovTest	(	TString	mode,
		TH1 *	h1,
		TH1 *	h2 = 0,
		TF1 *	pdf = 0,
		Double_t	nr = 1000,
		TH1F *	ksh = 0,
		Int_t	ncut = 0,
		Double_t *	nrx = 0,
		Int_t	mark = 1 )

// Perform the Kolmogorov-Smirnov (KS) test on a 1-dimensional histogram "h1",
// e.g. an observed distribution which may contain a signal, and a reference
// distribution ("h2" or "pdf"), for instance a background (hypothesis).
// The specification of the reference distribution can be provided either in
// histogram format "h2" or via a probability distribution function "pdf" (but not both),
// as outlined below.
// In case the reference distribution is specified via a histogram "h2", this histogram
// must have the same range and binning as the histogram "h1".
// In case the reference distribution is specified via the function "pdf",
// the range etc. will be automatically selected to match the input histogram "h1" in
// order to perform the KS test.
// Note : The function "pdf" does not need to be normalised.
//
// This facility is an extension of the memberfunction KolmogorovTest of the ROOT class TH1.
// Note that in the ROOT facility the role of "h1" and "h2" is inverted.
//
// The meaning of the returned value depends on the selected testing performance,
// as specified via the input parameter "mode" (see below).
//
// In case the P-value is requested, the return value amounts to the fraction of recorded
// maximum KS distance values with dmax>=d0, based on "nr" repetitions of a KS test for which
// at each repetition "n" random entries have been drawn from the reference distribution (hypothesis).
// Each repetition is called a pseudo experiment.
// The number of random entries "n" of each pseudo experiment is the same as the number of entries of
// the input histogram "h1".
// The value d0 represents the maximum KS distance between "h1" and the reference distribution.
//
// Input arguments :
// -----------------
// mode : A string of characters to specify the required functionality of the KS test (see below)
// nr   : The number of repetitions (see note 2) of the KS test with n random background entries.
// h1   : The observed experimental distribution in histogram format.
// h2   : Reference distribution in histogram format.
// pdf  : Function describing some (hypothetical) reference distribution (see note 4).
// ksh  : Histogram with the KS dmax values obtained from the pseudo experiments (see notes 2 and 3).
// ncut : Number of dmax>=d0 values to be obtained to trigger an early stop of the pseudo experiments.
//        In case ncut=0 all the specified "nr" pseudo experiments will be performed. 
// nrx  : Returned number of actually performed pseudo experiments (see note 1).
//        (only if a non-zero "nrx" value was also provided on input)
// mark : Flag to activate (mark=1) the marking of the threshold dmax value (d0) by a vertical line in the "ksh" histogram.
//        Also the corresponding P-value will be mentioned in the legend.
//
// Via the character string "mode" the performance of the KS test is specified as follows :
//
// "U" : Include Underflows in the KS test
// "O" : Include Overflows in the KS test
// "N" : Include comparison of histogram Normalizations in addition to the shapes for the KS test probability (see note 4)
// "M" : Return the Maximum KS distance
// "K" : Return the standard KS test Probability
// "P" : Return the P-value of the maximum KS distance based on a number of pseudo experiments
// "I" : Provide output with Information of the KS test result
//
// Examples :
// ----------
// mode="UONK" returns the standard KS Probability including Underflows, Overflows and Normalizations
// mode="PI" returns the P-value of the maximum KS distance and provides relevant KS test information
// mode="MPI" returns -1 (conflicting input) 
//
// Notes :
// -------
// 1) The number of repetitions "nr" and "nrx" are of type "double" to allow for large numbers.
//    Obviously these variables are meant to represent only integer counts.
//
// 2) In case a non-zero input argument "ncut" is provided, the number of pseudo experiments will be stopped
//    as soon as "ncut" values of dmax>=d0 are obtained.
//    When a large number of repetitions "nr" was specified, this allows an "early stop" and as such
//    a significant reduction of the CPU time. In case the number "ncut" was not reached, the performance
//    of pseudo experiments will stop as soon as "nr" repetitions have been performed.
//    However, when nr=0 was specified the pseudo experiments will be repeated until the number "ncut"
//    is reached or when the number of repetitions has reached the maximum allowed value of 1e19.
//    In case a non-zero input argument "nrx" is provided the number of actually performed pseudo experiments
//    will be returned via this same argument "nrx".
//
// 3) In case a histogram "ksh" is provided, this function recreates the histogram (and a legend if "mark" is activated).
//
// 4) In case the (hypothetical) reference distribution is specified via the function "pdf", the errors
//    of the reference distribution are set to zero. This is a so called "Single sample test".
//    Consequently, it doesn't make sense to include the normalization (mode="N") in the KS-test, so in
//    these cases the mode="N" will be ignored. 
//
// For practical reasons the maximum value of "nr" has been limited to 1e19, which is about
// the corresponding maximum value of an unsigned 64-bit integer.
//
// Default values are : h2=0, pdf=0, nr=1000, ksh=0, ncut=0, nrx=0 and mark=1.
//
// In the case of inconsistent input, a value of -1 is returned.
//
//--- Nick van Eijndhoven 19-nov-2018 IIHE-VUB Brussel

Definition at line 10568 of file NcAstrolab.cxx.

LabLocalFramePanel()

void NcAstrolab::LabLocalFramePanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the Lab local reference frame specification GUI panel.

Definition at line 17985 of file NcAstrolab.cxx.

LabLocationPanel()

void NcAstrolab::LabLocationPanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the Lab location and experiment specification GUI panel.

Definition at line 17712 of file NcAstrolab.cxx.

ListBurstHistograms()

void NcAstrolab::ListBurstHistograms

(

)

const

// Provide a list of all the stored transient burst histograms
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 17538 of file NcAstrolab.cxx.

ListBurstParameters()

void NcAstrolab::ListBurstParameters

(

)

const

// Listing of all the burst parameter settings
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 11659 of file NcAstrolab.cxx.

ListDataNames()

void NcAstrolab::ListDataNames

(

)

// Listing of the correspondance table between physical observables
// and their names in a ROOT input Tree.

Definition at line 11215 of file NcAstrolab.cxx.

ListSignals()

void NcAstrolab::ListSignals	(	TString	frame,
		TString	mode,
		Int_t	ndig = 1,
		TString	emode = "T",
		Int_t	nmax = 10,
		Int_t	j = -1,
		Int_t	type = -1,
		NcTimestamp *	ts = 0,
		TString	name = "*" )

// List stored measurements and/or reference signals in user specified coordinates
// at a specific timestamp if their name matches the provided name pattern "name", where name="*" means all.
// Measurements are listed according to the timestamp of their actual stored recording, which may be
// a scrambled timestamp according to the invokation of the memberfunction SetTimeScramble().
// For reference signals the actual timestamp of the j-th (j=1 is first) stored measurement is used.
// In case j=0 or no (timestamp of the) j-th measurement is available, the provided timestamp will be taken,
// where a provided ts=0 (which is the default) refers to the current timestamp of the lab.
// For j<0 the timestamp of the actual recording of the reference signal will be used.
// In case no corresponding stored signal is available or one of the input arguments is
// invalid, no printout is produced.
//
// type = 0 --> List the data of stored reference signals
//        1 --> List the data of stored measured signals
//      < 0 --> List the data of both measured and reference signals  
//
// The argument "nmax" specifies the maximum number of measured c.q. reference signals
// that will be listed. When nmax<0 all stored measured c.q. reference signals are listed.
//
// The argument "ndig" specifies the number of digits for the fractional
// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
// Rounding will be performed, so an arcsecond count of 3.473 with ndig=1
// will appear as 03.5 on the output, but with ndig=2 it will show 03.47.
// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
//
// Note : The angle info is printed without additional spaces or "endline".
//        This allows the print to be included in various composite output formats.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the listing in case of equatorial (a,d) coordinates.
//
// mode = "M" --> Listed coordinates are the mean values 
//        "T" --> Listed coordinates are the true values 
//        "B" --> Lists Besselian (B1950) reference epoch coordinates 
//        "J" --> Lists Julian (J2000) reference epoch coordinates 
//
// The input parameter "mode" also determines which type of time and
// local hour angle will appear in the listing.
//
// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
//        "B" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//        "J" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//
// The default values are ndig=1, emode="T", nmax=10, j=-1, type=-1, ts=0 and name="*".

Definition at line 3768 of file NcAstrolab.cxx.

LoadInputData()

void NcAstrolab::LoadInputData	(	Bool_t	src,
		TString	file,
		TString	tree,
		Int_t	date1 = 0,
		Int_t	date2 = 0,
		Int_t	nmax = -1,
		TString	type = "-" )

// Generic facility to load source (e.g. GCN) or observed event data.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided as numerical values via a ROOT Tree which will be
// searched for data on the variable names as specified via SetDataNames().
//
// The necessary minimal set of pre-defined observables (see SetDataNames) is :
// (a,b,Tobs) [and Date in case Tobs is in units "hms" or "hrs"].
// The observables (a,b,Tobs) are used to automatically construct and store the signal entries,
// as outlined in SetSignal().
//
// All requested values will (also) be stored in NcSignal slots with the pre-defined
// observable name and in the standard units as defined in SetDataNames().
//
// Special standard units used for storage are :
// 1) yyyymmdd for Date
// 2) MJD for Tobs, Tstart and Tend.
// 3) Degrees for all angles
//
// Note that the values of "a" and "b" are not stored as NcSignal slots, since their
// meaning depends on the used reference frame.
// Retrieval of the values of "a" and "b" should be performed via the GetSignal() facility.
//
// In case data for a requested observable is not present, the non-physical value -999
// will be stored, unless the user has selected random generation of that observable
// via the specifications in SetBurstParameter(). 
//
// Input arguments :
// -----------------
// src   : Flag to indicate source (e.g. GCN) data (kTRUE) or observed events (kFALSE)
// file  : Name of the input file containing the ROOT Tree (wildcards are allowed)
// tree  : Name of the Tree containing the data
// date1 : The date (yyyymmdd) of the start of the observation period [date1,date2] (0=No restriction)
// date2 : The date (yyyymmdd) of the end of the observation period [date1,date2] (0=No restriction)
// nmax  : Maximum number of sources or events to be accepted from this input file (<0 : no limitation)
// type  : Identifier of the source (c.q. burst) or observed event (alert) type (e.g. "GRB", "GW", "IC",...)
//         In case no "Name" is provided as an "observable" in the input data, the provided "type" will
//         be combined with the Tobs data to construct names like GRB031025, IC190722 etc...
//         However, in case "Name" is provided in the input data, the corresponding string will be
//         used as the name for the source (c.q. burst) or observed event, irrespective of the provided "type". 
//         When type="-" the source type is set to "GRB" and the event type is set to "EVT", in case
//         no "Name" is provided as "observable" in the input data.
//
// The default values are date1=0, date2=0, nmax=-1 and type="-".
//
// Notes :
// -------
// 1) This memberfunction make be invoked several times to read different files to accumulate data.
// 2) The internal storage arrays will be compressed, so that the indices of previously stored objects may change.

Definition at line 11885 of file NcAstrolab.cxx.

MakeBurstDataStats()

void NcAstrolab::MakeBurstDataStats ( Int_t mode, Int_t nmugrb = 0 )

protected

// Internal memberfunction to determine and list the burst-data statistics.
//
// mode : 0 --> Invoked from GenBurstSignals()
//        1 --> Invoked from MatchBurstData()
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Default value is nmugrb=0.

Definition at line 14080 of file NcAstrolab.cxx.

MakeBurstEnergydist() [1/3]

void NcAstrolab::MakeBurstEnergydist	(	Int_t	mode,
		Double_t	alpha,
		Double_t	Emin,
		Double_t	Emax,
		Int_t	nbins = 1000 )

// Create a background (mode=1) or burst induced signal (mode=2) energy distribution
// on the interval [Emin,Emax] GeV based on a single power law with 
// spectral index "alpha" describing dN/dE=E^-alpha.
// If this memberfunction is invoked before GenBurstSignals(), the resulting 
// energy distribution will be used to draw random energy values for either the
// generated background or burst induced signal events via the memberfunctions
// GetBurstBackgroundEnergy() and GetBurstSignalEnergy(), respectively.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Example: To make a dN/dE=E^-2 burst induced signal energy distribution for 100 Gev < E < 10 PeV
//
// mode=2;
// alpha=2;
// Emin=100;
// Emax=1e7;
// nbins=1000;
// MakeBurstEnergydist(mode,alpha,Emin,Emax,nbins);
//
// The default value is nbins=1000.

Definition at line 12990 of file NcAstrolab.cxx.

MakeBurstEnergydist() [2/3]

void NcAstrolab::MakeBurstEnergydist	(	Int_t	mode,
		TF1 &	spec,
		Double_t	Emin,
		Double_t	Emax,
		Int_t	nbins = 1000 )

// Create a background (mode=1) or burst induced signal (mode=2) energy distribution
// on the interval [Emin,Emax] GeV based on the spectral function "spec" describing dN/dE.
// If this memberfunction is invoked before GenBurstSignals(), the resulting 
// energy distribution will be used to draw random energy values for either the
// generated background or burst induced signal events via the memberfunctions
// GetBurstBackgroundEnergy() and GetBurstSignalEnergy(), respectively.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Example: To make a dN/dE=E^-2 burst induced signal energy distribution for 100 Gev < E < 10 PeV
//
// mode=2;
// TF1 spec("spec","pow(x,-2.)");
// xmin=100;
// xmax=1e7;
// nbins=1000;
// MakeBurstEnergydist(mode,spec,Emin,Emax,nbins);
//
// The default value is nbins=1000.

Definition at line 12903 of file NcAstrolab.cxx.

MakeBurstEnergydist() [3/3]

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 = 1000 )

// Create a background (mode=1) or burst induced signal (mode=2) energy distribution
// on the interval [Emin,Emax] GeV based on observed archival energy data.
// If this memberfunction is invoked before GenBurstSignals(), the resulting 
// log10(E) distribution will be used to draw random energy values for either the
// generated background or burst induced signal events via the memberfunctions
// GetBurstBackgroundEnergy() and GetBurstSignalEnergy(), respectively.
//
// Note : Only those data will be used that correspond with the selected
//        declination interval for the burst investigations.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided via a ROOT Tree which contains at least
// the specified variable names indicated below.
//
// Notes :
// -------
// 1) With mode<0 (see below) this memberfunction may be invoked several times to
//    read different files to accumulate data.
// 2) In case a corresponding parametrized energy distribution exists,
//    this will always be replaced by a new energy distribution based on data.
// 3) In case observed archival data for burst induced signal events is loaded,
//    the redshift correction for signal events will be deactivated. 
//
// Input arguments :
// -----------------
// mode   :  1 --> Always create a new energy distribution for background events.
//        :  2 --> Always create a new energy distribution for burst induced signal events.
//        : -1 --> Create a new (if needed) or add data to an energy distribution for background events.
//        : -2 --> Create a new (if needed) or add data to an energy distribution for burst induced signal events.
// file   : Name of the input file containing the ROOT Tree (wildcards are allowed)
// tree   : Name of the Tree containing the data
// name1  : Name of the tree variable containing the log10(E) data (in GeV)
// name2  : Name of the tree variable containing the declination data
// u      : The units (see below) of the declination data
// Emin   : Minimal energy value in GeV
// Emax   : Maximal energy value in GeV
// nb     : Number of bins for the Energy distribution
//
// Specification of the angular units :
// ------------------------------------ 
// "rad" : input angle provided in radians
// "deg" : input angle provided in degrees
// "dms" : input angle provided in dddmmss.sss
// "hms" : input angle provided in hhmmss.sss
// "hrs" : input angle provided in fractional hours
//
// The default value is nb=1000.

Definition at line 13024 of file NcAstrolab.cxx.

MakeBurstRecoAngresdist()

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 = 100,
		Int_t	nba = 1000 )

// Create a reconstruction angle resolution vs. energy distribution on the interval [Emin,Emax] GeV
// based on observed or simulated archival data.
// The angular resolution range is fixed to [0,180] degrees. 
// If this memberfunction is invoked before GenBurstSignals(), the resulting
// distribution will be used to determine the reconstruction angular uncertainty
// for individual events by invokation of GetBurstRecoAngres().
//
// Note : Only those data will be used that correspond with the selected
//        declination interval for the burst investigations.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided via a ROOT Tree which contains at least
// the specified variable names indicated below.
//
// Input arguments :
// -----------------
// file   : Name of the input file containing the ROOT Tree (wildcards are allowed)
// tree   : Name of the Tree containing the data
// name1  : Name of the tree variable containing the log10(E) data (in GeV)
// name2  : Name of the tree variable containing the reconstruction angle uncertainty
// ua     : The units (see below) of the angular uncertainty data
// name3  : Name of the tree variable containing the declination data
// ud     : The units (see below) of the declination data
// Emin   : Minimal energy value in GeV
// Emax   : Maximal energy value in GeV
// nbe    : Number of bins for the Energy axis
// nba    : Number of bins for the Angular axis
//
// Specification of the angular units :
// ------------------------------------ 
// "rad" : input angle provided in radians
// "deg" : input angle provided in degrees
// "dms" : input angle provided in dddmmss.sss
// "hms" : input angle provided in hhmmss.sss
// "hrs" : input angle provided in fractional hours
//
// The default values are nbe=100 and nba=1000.
//
// Note : This memberfunction may be invoked several times to read different files
//        to accumulate data.

Definition at line 13208 of file NcAstrolab.cxx.

MakeBurstSigmaPosdist()

void NcAstrolab::MakeBurstSigmaPosdist	(	TString	file,
		TString	tree,
		TString	name,
		TString	u,
		Int_t	nb = 900,
		Float_t	xmin = 0,
		Float_t	xmax = 90 )

// Read observed archival 1-sigma burst position uncertainty data and create the corresponding distribution.
// If this memberfunction is invoked before LoadBurstGCNdata() or GenBurstGCNdata(),
// the resulting distribution will be used to draw random 1-sigma burst position uncertainty values
// (if requested) for the bursts without localisation uncertainty information.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided via a ROOT Tree which contains at least
// the specified variable name indicated below.
//
// Input arguments :
// -----------------
// file   : Name of the input file containing the ROOT Tree (wildcards are allowed)
// tree   : Name of the Tree containing the data
// name   : Name of the variable in the Tree containing the 1-sigma angular localisation uncertainty data
// u      : Units of the angular localisation uncertainty input data (see below)
// nb     : Number of bins for the resulting distribution
// xmin   : Minimal value for the 1-sigma position uncertainty in degrees
// xmax   : Maximal value for the 1-sigma position uncertainty in degrees
//
// Specification of the angular units :
// ------------------------------------ 
// "rad" : angular uncertainty provided in radians
// "deg" : angular uncertainty provided in degrees
// "dms" : angular uncertainty provided in dddmmss.sss
// "hms" : angular uncertainty provided in hhmmss.sss
// "hrs" : angular uncertainty provided in fractional hours
//
// The default values are nb=900, xmin=0 and xmax=90.
//
// Note : This memberfunction may be invoked several times to read different files
//        to accumulate data.

Definition at line 12764 of file NcAstrolab.cxx.

MakeBurstT90dist()

void NcAstrolab::MakeBurstT90dist	(	TString	file,
		TString	tree,
		TString	name,
		Int_t	nb = 50,
		Float_t	xmin = -5,
		Float_t	xmax = 5 )

// Read observed archival T90 data and create a log10(T90) distribution.
// If this memberfunction is invoked before LoadBurstGCNdata() or GenBurstGCNdata(),
// the resulting log10(T90) distribution will be used to draw random T90 values
// (if requested) for the bursts without T90 information.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided via a ROOT Tree which contains at least
// the specified variable name indicated below.
//
// Input arguments :
// -----------------
// file   : Name of the input file containing the ROOT Tree (wildcards are allowed)
// tree   : Name of the Tree containing the data
// name   : Name of the variable in the Tree containing the T90 data
// nb     : Number of bins for the T90 distribution
// xmin   : Minimal value for log10(T90)
// xmax   : Maximal value for log10(T90)
//
// The default values are nb=50, xmin=-5 and xmax=5.
//
// Note : This memberfunction may be invoked several times to read different files
//        to accumulate data.

Definition at line 12637 of file NcAstrolab.cxx.

MakeBurstZdist()

void NcAstrolab::MakeBurstZdist	(	TString	file,
		TString	tree,
		TString	name,
		Int_t	nb = 200,
		Float_t	zmin = 0,
		Float_t	zmax = 20 )

// Read observed archival redshift data and create the corresponding distribution.
// Also the corresponding distribution of the Proper Distance at the time of
// observation (called the Physical Distance) will be created.
// If this memberfunction is invoked before LoadBurstGCNdata() or GenBurstGCNdata(),
// the plain observed redshift distribution will be used to draw random z values
// (if requested) for the bursts without redshift information.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The input data has to be provided via a ROOT Tree which contains at least
// the specified variable name indicated below.
//
// Input arguments :
// -----------------
// file   : Name of the input file(s) containing the ROOT Tree (wildcards are allowed)
// tree   : Name of the Tree containing the data
// name   : Name of the variable in the Tree containing the redshift data
// nb     : Number of bins for the z-distribution
// zmin   : Minimal z-value
// zmax   : Maximal z-value
//
// The default values are nb=200, zmin=0 and zmax=20.
//
// Note : This memberfunction may be invoked several times to read different files
//        to accumulate data.

Definition at line 12496 of file NcAstrolab.cxx.

MapCinfo()

void NcAstrolab::MapCinfo

(

Int_t

i

)

// Action on a button from the category selection box.

Definition at line 18150 of file NcAstrolab.cxx.

MapClose()

void NcAstrolab::MapClose

(

)

// Close the SkyMapPanel window but do NOT exit the current ROOT session.

Definition at line 19174 of file NcAstrolab.cxx.

MapDateTime()

void NcAstrolab::MapDateTime

(

const char *

text

)

// Action on the time specification entry field.

Definition at line 17938 of file NcAstrolab.cxx.

MapDcoord()

void NcAstrolab::MapDcoord

(

Int_t

i

)

// Action on a button from the coordinate system selection box.

Definition at line 18830 of file NcAstrolab.cxx.

MapDname()

void NcAstrolab::MapDname

(

const char *

text

)

// Action on the draw/list entry name selection field.

Definition at line 18946 of file NcAstrolab.cxx.

MapDoptions()

void NcAstrolab::MapDoptions

(

Int_t

i

)

// Action on an button from the draw/list options group.

Definition at line 18901 of file NcAstrolab.cxx.

MapDraw()

void NcAstrolab::MapDraw

(

)

// Draw the skymap.

Definition at line 19144 of file NcAstrolab.cxx.

MapEa()

void NcAstrolab::MapEa

(

const char *

text

)

// Action on the entries a coordinate specification field.

Definition at line 18415 of file NcAstrolab.cxx.

MapEb()

void NcAstrolab::MapEb

(

const char *

text

)

// Action on the entries b coordinate specification field.

Definition at line 18439 of file NcAstrolab.cxx.

MapEcoord()

void NcAstrolab::MapEcoord

(

Int_t

i

)

// Action on a button from the entry coordinate frame selection box.

Definition at line 18463 of file NcAstrolab.cxx.

MapEname()

void NcAstrolab::MapEname

(

const char *

text

)

// Action on the (optional) entry name selection field.

Definition at line 18491 of file NcAstrolab.cxx.

MapEnter()

void NcAstrolab::MapEnter

(

)

// Enter the provided entry.

Definition at line 18502 of file NcAstrolab.cxx.

MapEnterSolar()

void NcAstrolab::MapEnterSolar

(

)

// Enter the seleced Solar system objects as reference object.

Definition at line 19030 of file NcAstrolab.cxx.

MapEtype()

void NcAstrolab::MapEtype

(

Int_t

i

)

// Action on a button from the entry type selection box.

Definition at line 18479 of file NcAstrolab.cxx.

MapExit()

void NcAstrolab::MapExit

(

)

// Exit this ROOT session.

Definition at line 19193 of file NcAstrolab.cxx.

MapExperiment()

void NcAstrolab::MapExperiment

(

Int_t

i

)

// Action on a button from the lab experiment site box.

Definition at line 17818 of file NcAstrolab.cxx.

MapIname()

void NcAstrolab::MapIname

(

const char *

text

)

// Treating the text of the entry name for the information panel.

Definition at line 18192 of file NcAstrolab.cxx.

MapInfo()

void NcAstrolab::MapInfo

(

)

// Provide the requested info.

Definition at line 18203 of file NcAstrolab.cxx.

MapLabLframeEnter()

void NcAstrolab::MapLabLframeEnter

(

)

// Enter the specified local frame parameters.
// Note : Local frame parameters for established experimental sites
//        may NOT be modified.

Definition at line 18045 of file NcAstrolab.cxx.

MapLabTS()

void NcAstrolab::MapLabTS

(

)

// Use the current date/time selection as the Lab timestamp.

Definition at line 17965 of file NcAstrolab.cxx.

MapList()

void NcAstrolab::MapList

(

)

// List the entries of the skymap.

Definition at line 19118 of file NcAstrolab.cxx.

MapListOptionsPanel()

void NcAstrolab::MapListOptionsPanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the GUI panel to specify various Mapping and Listing options.

Definition at line 18537 of file NcAstrolab.cxx.

MapLocb()

void NcAstrolab::MapLocb

(

const char *

text

)

// Action on the lab latitude entry field.

Definition at line 17794 of file NcAstrolab.cxx.

MapLocEnter()

void NcAstrolab::MapLocEnter

(

)

// Enter the provided lab location entry.

Definition at line 17842 of file NcAstrolab.cxx.

MapLocId()

void NcAstrolab::MapLocId

(

const char *

text

)

// Action on the lab detector element Id entry field.

Definition at line 17830 of file NcAstrolab.cxx.

MapLocl()

void NcAstrolab::MapLocl

(

const char *

text

)

// Action on the lab longitude entry field.

Definition at line 17782 of file NcAstrolab.cxx.

MapMarkColor()

void NcAstrolab::MapMarkColor

(

Int_t

i

)

// Action on the marker color selection box.

Definition at line 18984 of file NcAstrolab.cxx.

MapMarkSize()

void NcAstrolab::MapMarkSize

(

const char *

text

)

// Action on the marker size selection field.

Definition at line 18957 of file NcAstrolab.cxx.

MapMarkStyle()

void NcAstrolab::MapMarkStyle

(

Int_t

i

)

// Action on the marker style selection box.

Definition at line 18969 of file NcAstrolab.cxx.

MapMarkType()

void NcAstrolab::MapMarkType

(

Int_t

i

)

// Action on the markers entry type selection box.

Definition at line 18999 of file NcAstrolab.cxx.

MapMerC()

void NcAstrolab::MapMerC

(

const char *

text

)

// Action on the central meridian specification field.

Definition at line 18877 of file NcAstrolab.cxx.

MapMerMode()

void NcAstrolab::MapMerMode

(

Int_t

i

)

// Action on a button from the meridian ordering selection box.

Definition at line 18865 of file NcAstrolab.cxx.

MapMerUc()

void NcAstrolab::MapMerUc

(

Int_t

i

)

// Action on a button from the central meridian angular format selection box.

Definition at line 18889 of file NcAstrolab.cxx.

MapNdigs()

void NcAstrolab::MapNdigs

(

const char *

text

)

// Action on the draw/list Ndigs selection field.

Definition at line 18934 of file NcAstrolab.cxx.

MapNmax()

void NcAstrolab::MapNmax

(

const char *

text

)

// Action on the draw/list Nmax selection field.

Definition at line 18922 of file NcAstrolab.cxx.

MapProj()

void NcAstrolab::MapProj

(

Int_t

i

)

// Action on a button from the projection selection box.

Definition at line 18846 of file NcAstrolab.cxx.

MapRemove()

void NcAstrolab::MapRemove

(

)

// Remove the entry/entries specified by type and name pattern.

Definition at line 18519 of file NcAstrolab.cxx.

MapRemoveSolar()

void NcAstrolab::MapRemoveSolar

(

)

// Remove the seleced Solar system object(s) from the reference objects.

Definition at line 19051 of file NcAstrolab.cxx.

MapSolar()

void NcAstrolab::MapSolar

(

Int_t

i

)

// Action on a button from the Solar system selection group.

Definition at line 19010 of file NcAstrolab.cxx.

MapTimeType()

void NcAstrolab::MapTimeType

(

Int_t

i

)

// Action on the time type selection box.

Definition at line 17949 of file NcAstrolab.cxx.

MapTinfo()

void NcAstrolab::MapTinfo

(

Int_t

i

)

// Action on a button from the time type selection box.

Definition at line 18162 of file NcAstrolab.cxx.

MapUa()

void NcAstrolab::MapUa

(

Int_t

i

)

// Action on a button from the a coordinate angular format selection box.

Definition at line 18427 of file NcAstrolab.cxx.

MapUb()

void NcAstrolab::MapUb

(

Int_t

i

)

// Action on a button from the b coordinate angular format selection box.

Definition at line 18451 of file NcAstrolab.cxx.

MapUinfo()

void NcAstrolab::MapUinfo

(

Int_t

i

)

// Action on a button from the info angular format selection box.

Definition at line 18180 of file NcAstrolab.cxx.

MapUloc()

void NcAstrolab::MapUloc

(

Int_t

i

)

// Action on a button from the lab angular unit selection box.

Definition at line 17806 of file NcAstrolab.cxx.

MatchBurstData() [1/2]

void NcAstrolab::MatchBurstData	(	NcDevice &	matches,
		Int_t	i1 = 1,
		Int_t	i2 = 0,
		Int_t	itype = 0,
		Int_t	j1 = 1,
		Int_t	j2 = 0,
		Int_t	jtype = 1 )

// Provide information about the matching in space and time of the stored
// reference signal(s) and/or measurement(s).
// Signals are regarded as matching if the positional angular difference
// and the absolute value of the time difference don't exceed the parameters
// as specified by SetBurstParameter().
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The information (see below) for the observed matches is provided via the NcDevice argument "matches",
// where each matching pair is recorded as a "hit" with the corresponding NcSignal data.
// Consequently, the number of matches can be obtained as the number of "hits" in the NcDevice.
//
// Note : This memberfunction will completely reset and re-define the NcDevice "matches".
//
// It is possible to investigate only a sub-set of the stored reference signals c.q. measurements
// via the input arguments "i1", "i2", "itype", "j1" and "j2", "jtype" as follows :
//
// i1    : Start index of the stored signals to be investigated (1=first stored signal)
// i2    : End index of the stored signals to be investigated (0=last stored signal)
// itype : 0 ==> [i1,i2] refer to stored reference signals
//         1 ==> [i1,i2] refer to stored measurements
// j1    : Start index of the stored signals to be investigated (1=first stored signal)
// j2    : End index of the stored signals to be investigated (0=last stored signal)
// jtype : 0 ==> [j1,j2] refer to stored reference signals
//         1 ==> [j1,j2] refer to stored measurements
//
// Note : Using itype=jtype allows investigation of (self)correlations within a sample. 
//        In this case the matching of a signal with itself will be skipped.
//
// The default values are i1=1, i2=0, itype=0, j1=1, j2=0 and jtype=1.
//
// The data for each matching signal pair provided as a "hit" of the NcDevice object is the following :
// Name   : Indicating the name (if any) of object1
// Title  : Indicating the name (if any) of object2
// Slot 1 : "type1"  --> Type of object1 (0=reference signal, 1=measurement) 
// Slot 2 : "index1" --> Storage index of object1 (see memberfunction GetSignal)
// Slot 3 : "type2"  --> Type of object2 (0=reference signal, 1=measurement) 
// Slot 4 : "index2" --> Storage index of object2 (see memberfunction GetSignal)
// Slot 5 : "psi"    --> Opening angle between object2 and object1 in units as specified via "au"
// Slot 6 : "t2-t1"  --> Time offset between object2 and object1 in units as specified via "tu" and "mode"
//                       (t2-t1)<0 in case object2 was recorded earlier than object1.
//
// The NcDevice object itself provides the data of the best encountered matchings as follows :
//
// Slot 1 : "psimin" --> Minimal encountered opening angle in units as specified via "au"
// Slot 2 : "dtmin"  --> Minimal encountered time offset |t2-t1| in units as specified via "tu" and "mode"
// Slot 3 : "ipsi"   --> Index of the hit that corresponds to the minimal opening angle
// Slot 4 : "idt"    --> Index of the hit that corresponds to the minimal time offset
//
// A full overview of all matchings can be obtained via NcDevice::Data().
//
// Note : In case scrambling has been activated, the results reflect the scrambled measurement(s).
//
// Usage example :
// ---------------
// NcAstrolab lab;
// // Enter various measurements and reference signals into "lab"
// lab.SetSignal(...);
// lab.SetSignal(...);
// lab.SetSignal(...);
// ...
// ...
// ...
// // Look for matches between all measurements and reference signals
// NcDevice matches;
// lab.MatchBurstData(matches);
//
// // List all the encountered matching details
// matches.Data();
//
// // Retrieve the minimal encountered opening angle
// Float_t angmin=matches.GetSignal(1);
//
// // Access the data of the matching pair (i.e. "hit") that yielded the minimal time offset
// Int_t ih=matches.GetSignal("idt");
// NcSignal* sx=matches.GetHit(ih);
// sx->Data();
//
// // Access the originally recorded signal of object1 that yielded the minimal opening angle
// // and retrieve its timestamp and the corresponding MJD. 
// ih=matches.GetSignal("ipsi");
// sx=matches.GetHit(ih);
// Int_t itype=sx->GetSignal("type1");
// Int_t i=sx->GetSignal("index1");
// sx=lab.GetSignal(i,itype);
// NcTimestamp* tx=sx->GetTimestamp();
// tx->Date();
// Double_t mjd1=tx->GetMJD();

Definition at line 15004 of file NcAstrolab.cxx.

MatchBurstData() [2/2]

void NcAstrolab::MatchBurstData	(	NcDevice &	matches,
		TString	name,
		Int_t	itype = 0,
		Int_t	j1 = 1,
		Int_t	j2 = 0,
		Int_t	jtype = 1 )

// Provide information about the matching in space and time of the stored
// reference signal(s) and/or measurement(s).
// Signals are regarded as matching if the positional angular difference
// and the absolute value of the time difference don't exceed the parameters
// as specified by SetBurstParameter().
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// The information (see below) for the observed matches is provided via the NcDevice argument "matches",
// where each matching pair is recorded as a "hit" with the corresponding NcSignal data.
// Consequently, the number of matches can be obtained as the number of "hits" in the NcDevice.
//
// Note : This memberfunction will completely reset and re-define the NcDevice "matches".
//
// It is possible to investigate only a sub-set of the stored reference signals c.q. measurements
// via the input arguments "j1" and "j2", "jtype" as follows :
//
// name  : The name of the object to be used for the matching with the stored signals 
// itype : 0 ==> The object "name" resides among the stored reference signals
//         1 ==> The object "name" resides among the stored measurements
// j1    : Start index of the stored signals to be investigated (1=first stored signal)
// j2    : End index of the stored signals to be investigated (0=last stored signal)
// jtype : 0 ==> [j1,j2] refer to stored reference signals
//         1 ==> [j1,j2] refer to stored measurements
//
// The default values are itype=0, j1=1, j2=0 and jtype=1.
//
// Note : In case the name specifies a solar system object which was not yet stored,
//        the corresponding signal will be created according to "itype" and initially
//        stored with the current timestamp of this NcAstrolab instance.
//        In the matching process the location of the solar system object will be updated
//        according to the timestamp of the other signal. 
//        All geocentric name specifications for solar system objects as indicated in the
//        docs of NcTimestamp::Almanac() are supported.
//
// The data for each matching signal pair provided as a "hit" of the NcDevice object is the following :
// Name   : Indicating the name (if any) of object1
// Title  : Indicating the name (if any) of object2
// Slot 1 : "type1"  --> Type of object1 (0=reference signal, 1=measurement) 
// Slot 2 : "index1" --> Storage index of object1 (see memberfunction GetSignal)
// Slot 3 : "type2"  --> Type of object2 (0=reference signal, 1=measurement) 
// Slot 4 : "index2" --> Storage index of object2 (see memberfunction GetSignal)
// Slot 5 : "psi"    --> Opening angle between object2 and object1 in units as specified via "au"
// Slot 6 : "t2-t1"  --> Time offset between object2 and object1 in units as specified via "tu" and "mode"
//                       (t2-t1)<0 in case object2 was recorded earlier than object1.
//
// The NcDevice object itself provides the data of the best encountered matchings as follows :
//
// Slot 1 : "psimin" --> Minimal encountered opening angle in units as specified via "au"
// Slot 2 : "dtmin"  --> Minimal encountered time offset |t2-t1| in units as specified via "tu" and "mode"
// Slot 3 : "ipsi"   --> Index of the hit that corresponds to the minimal opening angle
// Slot 4 : "idt"    --> Index of the hit that corresponds to the minimal time offset
//
// A full overview of all matchings can be obtained via NcDevice::Data().
//
// Note : In case scrambling has been activated, the results reflect the scrambled measurement(s).
//
// Usage example :
// ---------------
// NcAstrolab lab;
// // Enter various measurements and reference signals into "lab"
// lab.SetSignal(...);
// lab.SetSignal(...);
// lab.SetSignal(...);
// ...
// ...
// ...
// // Look for matches between all measurements and GRB190215A as reference signal
// NcDevice matches;
// lab.MatchBurstData(matches,"GRB190215A");
//
// // List all the encountered matching details
// matches.Data();
//
// // Retrieve the minimal encountered opening angle
// Float_t angmin=matches.GetSignal(1);
//
// // Access the data of the matching pair (i.e. "hit") that yielded the minimal time offset
// Int_t ih=matches.GetSignal("idt");
// NcSignal* sx=matches.GetHit(ih);
// sx->Data();
//
// // Access the originally recorded signal of object1 that yielded the minimal opening angle
// // and retrieve its timestamp and the corresponding MJD. 
// ih=matches.GetSignal("ipsi");
// sx=matches.GetHit(ih);
// Int_t itype=sx->GetSignal("type1");
// Int_t i=sx->GetSignal("index1");
// sx=lab.GetSignal(i,itype);
// NcTimestamp* tx=sx->GetTimestamp();
// tx->Date();
// Double_t mjd1=tx->GetMJD();

Definition at line 15574 of file NcAstrolab.cxx.

MatchRefSignal()

TArrayI * NcAstrolab::MatchRefSignal	(	Double_t	da,
		TString	au,
		Double_t	dt,
		TString	tu,
		Int_t	mode = 1 )

// ***********************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility ***
// *** The user is advised to use the memberfunction MatchSignals() instead        ***
// ***********************************************************************************
//
// Provide the storage indices of the reference signals which match in space
// and time with the single stored measurement at storage index 1.
// The indices are returned via a pointer to a TArrayI object.
// In case no matches were found, the null pointer is returned.
// A reference signal is regarded as matching with the stored measurement
// if the positional angular difference doesn't exceed "da" and the absolute
// value of the time difference doesn't exceed "dt".
//
// The units of the angular difference "da" can be specified via the the "au"
// input argument, where
//
// au = "rad" --> Angular difference in (fractional) radians
//      "deg" --> Angular difference in (fractional) degrees
//
// The units of the time difference "dt" can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
// Also here mode=1 is the default value.
//
// Note : In case scrambling has been activated, the results reflect the scrambled measurement.

Definition at line 5362 of file NcAstrolab.cxx.

MatchSignals() [1/2]

void NcAstrolab::MatchSignals	(	NcDevice &	matches,
		Double_t	da,
		TString	au,
		Double_t	dt,
		TString	tu,
		Int_t	mode = 1,
		Int_t	i1 = 1,
		Int_t	i2 = 0,
		Int_t	itype = 0,
		Int_t	j1 = 1,
		Int_t	j2 = 0,
		Int_t	jtype = 1 )

// Provide information about the matching in space and time of the stored
// reference signal(s) and/or measurement(s).
// Signals are regarded as matching if the positional angular difference
// doesn't exceed "da" and the absolute value of the time difference doesn't exceed "dt".
//
// Notes :
// -------
// In case da<0 the signals will always be regarded as matching w.r.t. the positional angular difference. 
// In case dt<0 the signals will always be regarded as matching w.r.t. the time difference. 
//
// So, specifying da>0 and dt<0 will only check on matching of the locations of the signals, irrespective
// of the time of the various recordings. This is very convenient in the study of steady sources over
// extended time periods. 
//
// The information (see below) for the observed matches is provided via the NcDevice argument "matches",
// where each matching pair is recorded as a "hit" with the corresponding NcSignal data.
// Consequently, the number of matches can be obtained as the number of "hits" in the NcDevice.
//
// Note : This memberfunction will completely reset and re-define the NcDevice "matches".
//
// The units of the angular difference "da" can be specified via the the "au"
// input argument, where
//
// au = "rad" --> Angular difference in (fractional) radians
//      "deg" --> Angular difference in (fractional) degrees
//
// The units of the time difference "dt" can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
// Also here mode=1 is the default value.
//
// It is possible to investigate only a sub-set of the stored reference signals c.q. measurements
// via the input arguments "i1", "i2", "itype", "j1" and "j2", "jtype" as follows :
//
// i1    : Start index of the stored signals to be investigated (1=first stored signal)
// i2    : End index of the stored signals to be investigated (0=last stored signal)
// itype : 0 ==> [i1,i2] refer to stored reference signals
//         1 ==> [i1,i2] refer to stored measurements
// j1    : Start index of the stored signals to be investigated (1=first stored signal)
// j2    : End index of the stored signals to be investigated (0=last stored signal)
// jtype : 0 ==> [j1,j2] refer to stored reference signals
//         1 ==> [j1,j2] refer to stored measurements
//
// Note : Using itype=jtype allows investigation of (self)correlations within a sample. 
//        In this case the matching of a signal with itself will be skipped.
//
// The default values are i1=1, i2=0, itype=0, j1=1, j2=0 and jtype=1.
//
// The data for each matching signal pair provided as a "hit" of the NcDevice object is the following :
// Name   : Indicating the name (if any) of object1
// Title  : Indicating the name (if any) of object2
// Slot 1 : "type1"  --> Type of object1 (0=reference signal, 1=measurement) 
// Slot 2 : "index1" --> Storage index of object1 (see memberfunction GetSignal)
// Slot 3 : "type2"  --> Type of object2 (0=reference signal, 1=measurement) 
// Slot 4 : "index2" --> Storage index of object2 (see memberfunction GetSignal)
// Slot 5 : "psi"    --> Opening angle between object2 and object1 in units as specified via "au"
// Slot 6 : "t2-t1"  --> Time offset between object2 and object1 in units as specified via "tu" and "mode"
//                       (t2-t1)<0 in case object2 was recorded earlier than object1.
//
// The NcDevice object itself provides the data of the best encountered matchings as follows :
//
// Slot 1 : "psimin" --> Minimal encountered opening angle in units as specified via "au"
// Slot 2 : "dtmin"  --> Minimal encountered time offset |t2-t1| in units as specified via "tu" and "mode"
// Slot 3 : "ipsi"   --> Index of the hit that corresponds to the minimal opening angle
// Slot 4 : "idt"    --> Index of the hit that corresponds to the minimal time offset
//
// A full overview of all matchings can be obtained via NcDevice::Data().
//
// Note : In case scrambling has been activated, the results will reflect scrambled data,
//        but only in case of positive values of the time c.q. position scrambling modes.
//        For details see the docs of SetTimeScramble() and SetPositionScramble().
//
// Usage example :
// ---------------
// NcAstrolab lab;
// // Enter various measurements and reference signals into "lab"
// lab.SetSignal(...);
// lab.SetSignal(...);
// lab.SetSignal(...);
// ...
// ...
// ...
// // Look for matches between the measurements and reference signals
// // within 10 degrees opening angle and 600 seconds time offset.
// NcDevice matches;
// lab.MatchSignals(matches,10,"deg",600,"s");
//
// // List all the encountered matching details
// matches.Data();
//
// // Retrieve the minimal encountered opening angle
// Float_t angmin=matches.GetSignal(1);
//
// // Access the data of the matching pair (i.e. "hit") that yielded the minimal time offset
// Int_t ih=matches.GetSignal("idt");
// NcSignal* sx=matches.GetHit(ih);
// sx->Data();
//
// // Access the originally recorded signal of object1 that yielded the minimal opening angle
// // and retrieve its timestamp and the corresponding MJD. 
// ih=matches.GetSignal("ipsi");
// sx=matches.GetHit(ih);
// Int_t itype=sx->GetSignal("type1");
// Int_t i=sx->GetSignal("index1");
// sx=lab.GetSignal(i,itype);
// NcTimestamp* tx=sx->GetTimestamp();
// tx->Date();
// Double_t mjd1=tx->GetMJD();

Definition at line 5425 of file NcAstrolab.cxx.

MatchSignals() [2/2]

void NcAstrolab::MatchSignals	(	NcDevice &	matches,
		TString	name,
		Double_t	da,
		TString	au,
		Double_t	dt,
		TString	tu,
		Int_t	mode = 1,
		Int_t	itype = 0,
		Int_t	j1 = 1,
		Int_t	j2 = 0,
		Int_t	jtype = 1 )

// Provide information about the matching in space and time of the stored
// reference signal(s) and/or measurement(s).
// Signals are regarded as matching if the positional angular difference
// doesn't exceed "da" and the absolute value of the time difference doesn't exceed "dt".
//
// Notes :
// -------
// In case da<0 the signals will always be regarded as matching w.r.t. the positional angular difference. 
// In case dt<0 the signals will always be regarded as matching w.r.t. the time difference. 
//
// So, specifying da>0 and dt<0 will only check on matching of the locations of the signals, irrespective
// of the time of the various recordings. This is very convenient in the study of steady sources over
// extended time periods. 
//
// name  : The name of the object to be used for the matching with the stored signals 
// itype : 0 ==> The object "name" resides among the stored reference signals
//         1 ==> The object "name" resides among the stored measurements
// j1    : Start index of the stored signals to be investigated (1=first stored signal)
// j2    : End index of the stored signals to be investigated (0=last stored signal)
// jtype : 0 ==> [j1,j2] refer to stored reference signals
//         1 ==> [j1,j2] refer to stored measurements
//
// The default values are itype=0, j1=1, j2=0 and jtype=1.
//
// Note : In case the name specifies a solar system object which was not yet stored,
//        the corresponding signal will be created according to "itype" and initially
//        stored with the current timestamp of this NcAstrolab instance.
//        In the matching process the location of the solar system object will be updated
//        according to the timestamp of the other signal. 
//        All geocentric name specifications for solar system objects as indicated in the
//        docs of NcTimestamp::Almanac() are supported.
//
// The information (see below) for the observed matches is provided via the NcDevice argument "matches",
// where each matching pair is recorded as a "hit" with the corresponding NcSignal data.
// Consequently, the number of matches can be obtained as the number of "hits" in the NcDevice.
//
// Note : This memberfunction will completely reset and re-define the NcDevice "matches".
//
// The units of the angular difference "da" can be specified via the the "au"
// input argument, where
//
// au = "rad" --> Angular difference in (fractional) radians
//      "deg" --> Angular difference in (fractional) degrees
//
// The units of the time difference "dt" can be specified via the "tu" and "mode"
// input arguments. For details please refer to NcTimestamp::GetDifference().
// Also here mode=1 is the default value.
//
// The data for each matching signal pair provided as a "hit" of the NcDevice object is the following :
// Name   : Indicating the name (if any) of object1
// Title  : Indicating the name (if any) of object2
// Slot 1 : "type1"  --> Type of object1 (0=reference signal, 1=measurement) 
// Slot 2 : "index1" --> Storage index of object1 (see memberfunction GetSignal)
// Slot 3 : "type2"  --> Type of object2 (0=reference signal, 1=measurement) 
// Slot 4 : "index2" --> Storage index of object2 (see memberfunction GetSignal)
// Slot 5 : "psi"    --> Opening angle between object2 and object1 in units as specified via "au"
// Slot 6 : "t2-t1"  --> Time offset between object2 and object1 in units as specified via "tu" and "mode"
//
// The NcDevice object itself provides the data of the best encountered matchings as follows :
//
// Slot 1 : "psimin" --> Minimal encountered opening angle in units as specified via "au"
// Slot 2 : "dtmin"  --> Minimal encountered time offset in units as specified via "tu" and "mode"
// Slot 3 : "ipsi"   --> Index of the hit that corresponds to the minimal opening angle
// Slot 4 : "idt"    --> Index of the hit that corresponds to the minimal time offset
//
// A full overview of all matchings can be obtained via NcDevice::Data().
//
// Note : In case scrambling has been activated, the results reflect the scrambled measurement(s).
//
// Usage example :
// ---------------
// NcAstrolab lab;
// // Enter various measurements and reference signals into "lab"
// lab.SetSignal(...);
// lab.SetSignal(...);
// lab.SetSignal(...);
// ...
// ...
// ...
// // Look for matches between GRB140611A and the recorded measurements
// // within 10 degrees opening angle and 600 seconds time offset.
// NcDevice matches;
// lab.MatchSignals(matches,10,"deg",600,"s","GRB140611A");
//
// // List all the encountered matching details
// matches.Data();
//
// // Retrieve the minimal encountered opening angle
// Float_t angmin=matches.GetSignal(1);
//
// // Access the data of the matching pair (i.e. "hit") that yielded the minimal time offset
// Int_t ih=matches.GetSignal("idt");
// NcSignal* sx=matches.GetHit(ih);
// sx->Data();
//
// // Access the originally recorded signal of object2 that yielded the minimal opening angle
// // w.r.t. GRB140611A and retrieve its timestamp and the corresponding MJD. 
// ih=matches.GetSignal("ipsi");
// sx=matches.GetHit(ih);
// Int_t jtype=sx->GetSignal("type2");
// Int_t j=sx->GetSignal("index2");
// sx=lab.GetSignal(j,jtype);
// NcTimestamp* tx=sx->GetTimestamp();
// tx->Date();
// Double_t mjd2=tx->GetMJD();

Definition at line 5687 of file NcAstrolab.cxx.

Nutate()

void NcAstrolab::Nutate ( Nc3Vector & r, NcTimestamp * ts )

protected

// Correct mean right ascension and declination for the earth's nutation
// corresponding to the specified timestamp.
// The results are the so-called "true" (i.e. nutation corrected) values,
// corresponding to the specified timestamp.
// The method used is the new IAU 2000 one as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
//
// r  : Input vector containing the right ascension and declination information
//      in the form of standard Nc3Vector coordinates.
//      In spherical coordinates the phi corresponds to the right ascension,
//      whereas the declination corresponds to (pi/2)-theta.
// ts : Timestamp for which the corrected coordinate values are requested.
//
// Note : In case ts=0 the current timestamp of the lab will be taken.

Definition at line 4072 of file NcAstrolab.cxx.

Precess()

void NcAstrolab::Precess ( Nc3Vector & r, NcTimestamp * ts1, NcTimestamp * ts2 )

protected

// Correct mean right ascension and declination (as given for timestamp ts1)
// for the earth's precession, corresponding to the specified timestamp ts2.
// The results are the so-called "mean" (i.e. precession corrected) values,
// corresponding to the specified timestamp ts2.
// The method used is the new IAU 2000 one as described in the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
// Since the standard reference epoch is J2000, this implies that all
// input (a,d) coordinates will be first internally converted to the
// corresponding J2000 values before the precession correction w.r.t. the
// specified lab timestamp will be applied.
//
// r   : Input vector containing the right ascension and declination information
//       in the form of standard Nc3Vector coordinates.
//       In spherical coordinates the phi corresponds to the right ascension,
//       whereas the declination corresponds to (pi/2)-theta.
// ts1 : Timestamp corresponding to the input coordinate values.
// ts2 : Timestamp corresponding to the requested corrected coordinate values.
//
// Note : In case ts2=0 the current timestamp of the lab will be taken.

Definition at line 4034 of file NcAstrolab.cxx.

PrintAngle()

void NcAstrolab::PrintAngle	(	Double_t	a,
		TString	in,
		TString	out,
		Int_t	ndig = 1,
		Bool_t	align = kFALSE ) const

// Printing of angles in various formats.
//
// The input argument "a" denotes the angle to be printed. 
// The string arguments "in" and "out" specify the angular I/O formats.
//
// in = "rad" : input angle provided in radians
//      "deg" : input angle provided in degrees
//      "dms" : input angle provided in dddmmss.sss
//      "hms" : input angle provided in hhmmss.sss
//
// out = "rad" : output angle provided in radians
//       "deg" : output angle provided in degrees
//       "dms" : output angle provided in dddmmss.sss
//       "hms" : output angle provided in hhmmss.sss
//
// The argument "ndig" specifies the number of digits for the fractional
// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
// Rounding will be performed, so an arcsecond count of 3.473 with ndig=1
// will appear as 03.5 on the output, but with ndig=2 it will show 03.47.
// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
//
// The argument "align", when set to kTRUE, ensures that for a certain selected
// output format, all provided output strings will have the same length.
// This will allow the user to provide data in an aligned tabular format.
// When "align" is set to kFALSE, the produced output will be in the most
// compact format.
//
// The defaults are ndig=1 and align=kFALSE.
//
// Note : The angle info is printed without additional spaces or "endline".
//        This allows the print to be included in various composite output formats.

Definition at line 1257 of file NcAstrolab.cxx.

PrintSignal() [1/2]

void NcAstrolab::PrintSignal	(	TString	frame,
		TString	mode,
		NcTimestamp *	ts,
		Int_t	ndig,
		Int_t	jref = 0,
		TString	emode = "T",
		Int_t	type = 0,
		Bool_t	align = kFALSE )

// Print data of a stored signal in user specified coordinates at the specific timestamp ts.
// In case ts=0 the actual timestamp of the stored signal will be taken.
// In case no stored signal was available or one of the input arguments was
// invalid, no printout is produced.
//
// The argument "ndig" specifies the number of digits for the fractional
// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
// Rounding will be performed, so an arcsecond count of 3.473 with ndig=1
// will appear as 03.5 on the output, but with ndig=2 it will show 03.47.
// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
//
// The argument "align", when set to kTRUE, ensures that all coordinate
// output strings will have the same length.
// This will allow the user to provide data in an aligned tabular format.
// When "align" is set to kFALSE, the coordinate output will be in the most
// compact format.
//
// Note : The angle info is printed without additional spaces or "endline".
//        This allows the print to be included in various composite output formats.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the printout in case of equatorial (a,d) coordinates.
//
// mode = "M" --> Printed coordinates are the mean values 
//        "T" --> Printed coordinates are the true values 
//        "B" --> Prints Besselian (B1950) reference epoch coordinates 
//        "J" --> Prints Julian (J2000) reference epoch coordinates 
//
// The input parameter "mode" also determines which type of time and
// local hour angle will appear in the printout.
//
// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
//        "B" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//        "J" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//
// The input parameters "jref" and "type" allow printing of a measurement or a so-called "reference" signal.
// These reference signals may serve to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Printing of the j-th stored signal
//
// type = 0 --> Print data of a stored reference signal
//        1 --> Print data of a stored measurement
//
// Note :
// ------
// For jref=0 always the first stored measurement will be printed for backward compatibility,
// but the user is advised not to use this obsolete method anymore.
//
// Default values are jref=0, emode="T", type=0 and align=kFALSE.

Definition at line 3469 of file NcAstrolab.cxx.

PrintSignal() [2/2]

void NcAstrolab::PrintSignal	(	TString	frame,
		TString	mode,
		NcTimestamp *	ts,
		Int_t	ndig,
		TString	name,
		TString	emode = "T",
		Int_t	type = 0,
		Bool_t	align = kFALSE )

// Print data of the stored signal with the specified name and type in user specified coordinates
// at the specific timestamp ts.
// In case ts=0 the actual timestamp of the stored signal will be taken.
// In case no such stored signal was available or one of the input arguments was
// invalid, no printout is produced.
//
// type = 0 --> Print data of a stored reference signal
//        1 --> Print data of a stored measurement
//
// Note : In case the name specifies a solar system object which was not yet stored according to "type",
//        the corresponding signal will be created and stored with the specified timestamp.
//        In case ts=0 the solar system object will be stored with the current timestamp of
//        this NcAstrolab instance.
//        All geocentric name specifications for solar system objects as indicated in the
//        docs of NcTimestamp::Almanac() are supported.
//
// The argument "ndig" specifies the number of digits for the fractional
// part (e.g. ndig=6 for "dms" corresponds to micro-arcsecond precision).
// Rounding will be performed, so an arcsecond count of 3.473 with ndig=1
// will appear as 03.5 on the output, but with ndig=2 it will show 03.47.
// Due to computer accuracy, precision on the pico-arcsecond level may get lost.
//
// The argument "align", when set to kTRUE, ensures that all coordinate
// output strings will have the same length.
// This will allow the user to provide data in an aligned tabular format.
// When "align" is set to kFALSE, the coordinate output will be in the most
// compact format.
//
// Note : The angle info is printed without additional spaces or "endline".
//        This allows the print to be included in various composite output formats.
//
// The input parameter "frame" allows the user to specify the frame to which
// the coordinates refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d).
//
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b).
//
//          "hor" ==> Horizontal azimuth and altitude coordinates at the NcAstrolab location.
//
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b).
//
//          "loc" ==> Local spherical angles theta and phi at the NcAstrolab location.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the printout in case of equatorial (a,d) coordinates.
//
// mode = "M" --> Printed coordinates are the mean values 
//        "T" --> Printed coordinates are the true values 
//        "B" --> Prints Besselian (B1950) reference epoch coordinates 
//        "J" --> Prints Julian (J2000) reference epoch coordinates 
//
// The input parameter "mode" also determines which type of time and
// local hour angle will appear in the printout.
//
// mode = "M" --> Mean Sidereal Time (MST) and Local Mean Hour Angle (LMHA)
//        "T" --> Apparent Sidereal Time (AST) and Local Apparent Hour Angle (LAHA)
//        "B" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//        "J" --> Time and local hour angle type determined by input argument "emode" ("M" or "T")
//
// The default values are emode="T", type=0 and align=kFALSE

Definition at line 3683 of file NcAstrolab.cxx.

Project()

void NcAstrolab::Project ( Double_t l, Double_t b, TString proj, Double_t & x, Double_t & y )

protected

// Generic interface for projection of a (long,lat) pair onto a (x,y) pair.
//
// Meaning of the arguments :
// --------------------------
// l    : Longitude (e.g. right ascension)
// b    : Latitude (e.g. declination)
// proj : Projection mode (e.g. "ham")
// x    : The resulting x coordinate for the selected projection
// y    : The resulting x coordinate for the selected projection
//
// The available projection modes are :
//
// cyl  : Cylindrical equirectangular (straight b vs. l) projection plotted with colored markers
// cylh : Cylindrical equirectangular (straight b vs. l) projection plotted in a 2-D histogram
// ham  : Hammer equal area projection plotted with colored markers
// hamh : Hammer equal area projection plotted in a 2-D histogram
// ait  : Aitoff projection plotted with colored markers
// aith : Aitoff projection plotted in a 2-D histogram
// mer  : Mercator projection plotted with colored markers
// merh : Mercator projection plotted in a 2-D histogram
// ang  : Straight sin(b) vs. l plot with colored markers
// angh : Straight sin(b) vs. l plot in a 2-D histogram
//
// Note : The ang(h) plot allows for easy identification of an isotropic distribution.
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 7391 of file NcAstrolab.cxx.

ProjectAitoff()

void NcAstrolab::ProjectAitoff ( Double_t l, Double_t b, Double_t & x, Double_t & y )

protected

// Aitoff projection of a (long,lat) coordinate pair. 
// We adopt here a scale factor such that the range for x becomes [-2,2].
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 7487 of file NcAstrolab.cxx.

ProjectCylindrical()

void NcAstrolab::ProjectCylindrical ( Double_t l, Double_t b, Double_t & x, Double_t & y )

protected

// Equirectangular cylindrical projection of a (long,lat) coordinate pair 
// We adopt here a scale factor such that the range for x becomes [-2,2].
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 7454 of file NcAstrolab.cxx.

ProjectHammer()

void NcAstrolab::ProjectHammer ( Double_t l, Double_t b, Double_t & x, Double_t & y )

protected

// Hammer-Aitoff projection of a (long,lat) coordinate pair. 
// This is an equal-area projection.
// We adopt here a scale factor such that the range for x becomes [-2,2].
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 7470 of file NcAstrolab.cxx.

ProjectMercator()

void NcAstrolab::ProjectMercator ( Double_t l, Double_t b, Double_t & x, Double_t & y )

protected

// Mercator projection of a (long,lat) coordinate pair.
// At the poles this projection yields an infinite value for the y-coordinate.
// As such a latitude cut off has to be introduced.
//
// Commonly used cut off values (in degrees) are :
// -85.051 <= b <= 85.051 --> -pi <= y <= pi
// -89 <= b <= 89 --> 4.74 <= y <= 4.74
//
// We adopt here the 85.051 degree cutoff and a scale factor such that
// the range for y becomes [-1,1] and for x [-2,2].

Definition at line 7509 of file NcAstrolab.cxx.

RandomPosition()

void NcAstrolab::RandomPosition	(	Nc3Vector &	v,
		Double_t	thetamin,
		Double_t	thetamax,
		Double_t	phimin,
		Double_t	phimax )

// Provide a random angular position for the vector "v" according to an isotropic solid angle distribution.
// The random position will be located in [thetamin,thetamax] and [phimin,phimax].
//
// Notes :
// -------
// 1) All angles have to be given in degrees with theta=[0,180] and phi=[0,360].
// 2) The vector components c.q. errors of "v" don't have to be initialised.
//    In case the vector components of "v" are not initialised, the norm will be
//    automatically set to 1.
// 3) In case angular errors have been specified for the vector "v", the randomised vector
//    will obtain the same angular errors.

Definition at line 8960 of file NcAstrolab.cxx.

RemoveRefSignal() [1/2]

Int_t NcAstrolab::RemoveRefSignal	(	Int_t	j,
		Int_t	compress )

// ***********************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility ***
// *** The user is advised to use the memberfunction RemoveSignal() instead        ***
// ***********************************************************************************
//
// Remove the reference signal which was stored at the j-th position (j=1 is first).
// The return argument is the number of signals that were removed.
// Note : j=0 means that all stored reference signals will be removed.
//        j<0 allows array compression (see below) without removing any signals. 
//
// The "compress" parameter allows compression of the ref. signal storage array.
//
// compress = 1 --> Array will be compressed
//            0 --> Array will not be compressed
//
// Note : Compression of the storage array means that the indices of the
//        reference signals in the storage array will change.

Definition at line 3131 of file NcAstrolab.cxx.

RemoveRefSignal() [2/2]

Int_t NcAstrolab::RemoveRefSignal	(	TString	name,
		Int_t	compress )

// ***********************************************************************************
// *** This memberfunction is obsolete and is only kept for backward compatibility ***
// *** The user is advised to use the memberfunction RemoveSignal() instead        ***
// ***********************************************************************************
//
// Remove the reference signal with the specified name.
// The return argument is the number of signals that were removed.
//
// The "compress" parameter allows compression of the ref. signal storage array.
//
// compress = 1 --> Array will be compressed
//            0 --> Array will not be compressed
//
// Note : Compression of the storage array means that the indices of the
//        reference signals in the storage array will change.

Definition at line 3185 of file NcAstrolab.cxx.

RemoveSignal() [1/2]

Int_t NcAstrolab::RemoveSignal	(	Int_t	j,
		Int_t	type,
		Int_t	compress )

// Remove the signal of type "type" which was stored at the j-th position (j=1 is first).
// The return argument is the number of signals that were removed.
// Note : j=0 means that all stored signals of type "type" will be removed with compression.
//        j<0 allows array compression (see below) without removing any signals. 
//
// type = 0 --> Remove a reference signal
//      = 1 --> Remove a measured signal
//
// The "compress" parameter allows compression of the signal storage array of type "type".
//
// compress = 1 --> Array will be compressed
//            0 --> Array will not be compressed
//
// Note : Compression of the storage array means that the indices of the
//        signals in that storage array will change.

Definition at line 3215 of file NcAstrolab.cxx.

RemoveSignal() [2/2]

Int_t NcAstrolab::RemoveSignal	(	TString	name,
		Int_t	type,
		Int_t	compress )

// Remove the signal with the specified name and type.
// The return argument is the number of signals that were removed.
//
// Note : name="*" will remove all the entries of the specified type with compression.
//
// type = 0 --> Remove a reference signal
//      = 1 --> Remove a measured signal
//
// The "compress" parameter allows compression of the signal storage array of type "type".
//
// compress = 1 --> Array will be compressed
//            0 --> Array will not be compressed
//
// Note : Compression of the storage array means that the indices of the
//        signals in that storage array will change.
//
// In case name="" or no matching signal with the specified name and type is found,
// no action will be taken.

Definition at line 3284 of file NcAstrolab.cxx.

RemoveSignals()

Int_t NcAstrolab::RemoveSignals	(	TString	name,
		Int_t	type,
		Int_t	compress )

// Remove all signals that match the provided name pattern and type.
// The return argument is the number of signals that were removed.
//
// Note : name="*" will remove all the entries of the specified type with compression.
//
// type = 0 --> Remove a reference signal
//      = 1 --> Remove a measured signal
//
// The "compress" parameter allows compression of the signal storage array of type "type".
//
// compress = 1 --> Array will be compressed
//            0 --> Array will not be compressed
//
// Note : Compression of the storage array means that the indices of the
//        signals in that storage array will change.
//
// In case name="" or no matching signal with the specified name pattern and type is found,
// no action will be taken.

Definition at line 3326 of file NcAstrolab.cxx.

SetBmatrix()

void NcAstrolab::SetBmatrix ( )

protected

// Set the frame bias matrix elements.
// The formulas and numerical constants used are the ones from the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.

Definition at line 4100 of file NcAstrolab.cxx.

SetBurstParameter()

void NcAstrolab::SetBurstParameter	(	TString	name,
		Double_t	value )

// Specification of a certain transient burst parameter setting.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************
//
// Input arguments :
// -----------------
// name  : Name of the parameter to be set
// value : The parameter value to be set
//
// Default values will be initialized by the constructor of this class
// and can be displayed by invokation of the member function ListBurstParameters(). 
//
// To reset all parameters to their default values please invoke with name="*".
// This will also remove all the stored histograms related to burst investigations.
// If name="*" the provided value is irrelevant.
//
// The available parameter names are :
//
// Nmaxsrc;  // Maximal number of sources to be accepted for analysis (<0 : no limitation)
// Nmaxevt;  // Maximal number of observed events to be accepted for analysis (<0 : no limitation)
// RAmin     // Minimal right ascension (J2000 in degrees) for source c.q. event position acceptance
// RAmax     // Maximal right ascension (J2000 in degrees) for source c.q. event position acceptance
// Declmin   // Minimal declination (J2000 in degrees) for source c.q. event position acceptance
// Declmax   // Maximal declination (J2000 in degrees) for source c.q. event position acceptance
// T90min    // Minimal duration (t90 in sec) for burst acceptance (<0 : [|T90min|,T90max] with random T90 when missing in loaded data)
// T90max    // Maximal duration (t90 in sec) for burst acceptance
// Zmin      // Minimal redshift for source acceptance (<0 : [|Zmin|,Zmax] with random z when missing in loaded data)
// Zmax      // Maximal redshift for source acceptance
// Sigmamin  // Minimal position uncertainty (sigma in degrees) for source acceptance (<0 : [|Sigmamin|,Sigmamax] with random sigma when missing in loaded data)
// Sigmamax  // Maximal position uncertainty (sigma in degrees) for source acceptance
// Grbnu     // Maximum number of detectable simulated neutrinos per source (<0 : no statistical fluctuations)
// Avgrbz    // Average source redshift (<0 : determine from observations)
// Avgrbt90  // Average burst duration (T90) in seconds (<0 : determine from observations)
// Inburst   // Flag to indicate that the simulated neutrinos are produced coupled (1) or not (0) to the burst duration
// Dtnu      // Mean time diff. (in sec) between gamma/GW and simulated nu production (decoupled) or in T90 units w.r.t. trigger (coupled)
// Dtnus     // Sigma of time difference (in sec) between gamma/GW and simulated nu production (<0 is in T90 units)
// ESigmin   // Minimal event energy (in GeV) for source signal event generation
// ESigmax   // Maximal event energy (in GeV) for source signal event generation
// Ezcor     // Flag to activate redshift correction for the generated energy of simulated source signal events (1) or not (0)
// Emin      // Minimal event energy (in GeV) for event acceptance
// Emax      // Maximal event energy (in GeV) for event acceptance
// Alphasig  // Spectral index for a default dN/dE=E^-Alphasig source induced signal energy spectrum within [ESigmin,ESigmax]. See also MakeBurstEnergydist() 
// Alphabkg  // Spectral index for a default dN/dE=E^-Alphabkg background energy spectrum within [Emin,Emax]. See also MakeBurstEnergydist()
// Kinangle  // Neutrino-lepton kinematic opening angle selection for CC interactions (0=none 1=mean 2=median 3=draw from pdf)
// Angresmin // Minimal event reco angular resolution (sigma in degrees) for event acceptance
// Angresmax // Maximal event reco angular resolution (sigma in degrees) for event acceptance
// Angresfix // Fixed event reco angular resolution within [Angresmin,Angresmax] (also used when no distribution (value) is available)
// Recoangle // Reconstruction angular uncertainty selection (0=use Angresfix value  1=mean 2=median 3=draw from distribution)
// Sumsigmas // Sigma (summation) selection (-1=reco sigma only  0=source sigma only  1=linear summation  2=quadratic summation)
// Timres    // Neutrino detector time resolution (sec)
// Sensarea  // Area (in m^2) covered c.q. overlooked by the neutrino detector sensors (<=0 means not specified) 
// Bkgrate   // Mean rate (in Hz) of background events for the specified [Declmin,Declmax] interval (<0 : rate per steradian)
// Nbkg      // The number of requested background patches per source
// Tunits    // Time units for Tmin, Tmax, Tbin and VarTbin (0=days 1=hours 2=seconds 3=nanoseconds 4=picoseconds) 
// Tmin      // Lower bound of the search time window [Tmin,Tmax] where t=0 indicates the burst trigger
// Tmax      // Upper bound of the search time window [Tmin,Tmax] where t=0 indicates the burst trigger
//           Note : If Tmax<=Tmin the search time window is unrestricted (not applicable for simulation data) 
// Dawin     // Angular search circle (<0 is local zenith band) in degrees or units of sigma around (above/below) the source position (see Datype)
// Datype    // Type of Dawin (<0=Unrestricted 0=degrees 1=units of combined max. source/event sigma 2=units of combined actual source/event sigma) 
// Tbint90   // Flag to indicate whether Tbin represents time units (0) or units of average T90 (1)
// Tbin      // Time bin size (>0=time units or units of average T90  0=variable bins  <0 will result in a mean |Tbin| counts/bin)
// VarTbin   // Size (in time units) of the first time bin in case of variable time bins
// Abin      // Angular bin size in degrees (<0 will result in a mean |Abin| counts/bin)
//
// Note :
// ------
// In case variable time bins are selected, the search time window [Tmin,Tmax] will be centered
// around the burst trigger time (i.e. t=0) and the first bin will have a size of VarTbin time units.
// The size of subsequent time bins is multiplied by the average redshift factor (z+1) at each step.
// This is done in order to acount for the cosmological time dilation, which stretches all time differences.
//
// Default settings (tailored for IceCube 86 strings) :
// ----------------------------------------------------
// Nmaxsrc=-1
// Nmaxevt=-1
// [RAmin,RAmax]=[0,360]
// [Declmin,Declmax]=[-90,90]
// [T90min,T90max]=[1e-5,1e5]
// [Zmin,Zmax]=[-1e-6,20]
// [Sigmamin,Sigmamax]=[0,2]
// Grbnu=0;
// Avgrbz=-1
// Avgrbt90=-1
// Inburst=0
// Dtnu=0
// Dtnus=-0.5
// [ESigmin,ESigmax]=[1e3,1e10]
// Ezcor=1
// [Emin,Emax]=[200,1e7]
// Alphasig=2
// Alphabkg=3.5
// Kinangle=3
// [Angresmin,Angresmax]=[0,2]
// Angresfix=1
// Recoangle=3
// Sumsigmas=2
// Timres=1e-5
// Sensarea=1e6
// Bkgrate=-0.003/(2.*pi)
// Nbkg=1
// Tunits=2
// Tmin=-3600
// Tmax=3600
// Dawin=5
// Datype=0
// Tbint90=1
// Tbin=1
// VarTbin=10
// Abin=1

Definition at line 11272 of file NcAstrolab.cxx.

SetCentralMeridian()

void NcAstrolab::SetCentralMeridian	(	Int_t	mode = 0,
		Double_t	phi = 0,
		TString	u = "deg" )

// Set the central meridian and the orientation for the sky display.
// By default the central meridian is set at -999 in the constructor.
//
// Input arguments :
// -----------------
// mode =  0 : Automatic meridian and display setting.
//             For this mode the actual values of "phi" and "u" are irrelevant.
//             This is also the default setting in the constructor of this class.
//         1 : The horizontal scale will increase from left to right (e.g. 0h->24h) 
//        -1 : The horizontal scale will decrease from left to right (e.g. 24h->0h) 
// phi  :  Specification of the central meridian
// u    =  "rad" : phi angle provided in radians
//         "deg" : phi angle provided in degrees
//         "dms" : phi angle provided in dddmmss.sss
//         "hms" : phi angle provided in hhmmss.sss
//
// The default values are mode=0, phi=0 and u="deg".
//
// This routine is based on initial work by Garmt de Vries-Uiterweerd.

Definition at line 7346 of file NcAstrolab.cxx.

SetDataNames()

void NcAstrolab::SetDataNames	(	TString	obsname,
		TString	varname,
		TString	units = "1",
		TString	func = "none" )

// Specification of the correspondence table between pre-defined (physical) observables
// and their names in a ROOT input Tree.
// In order to be compatible with the generic data reading member function LoadInputData(),
// only the pre-defined (physical) observable names listed below are accepted.
//
// Note :
// ------
// Make sure to invoke InitDataNames() first, before providing the various settings here.
//
// Input arguments :
// -----------------
// obsname : Name of the (physical) observable (see below)
// varname : Name of the corresponding variable in the ROOT Tree
// units   : The units in which the input value is provided (see below)
//           This includes scaling w.r.t. standard units like GeV, pc, second etc.
//           Example : units="1e3" would represent TeV instead of the standard GeV in case of an energy.
// func    : Function that has been applied on the value of the observable (see below).
//
// Accepted (physical) observable names are :
// ------------------------------------------
// Name      : Name of the object or observation (e.g. GRB031025A or IC190722A)
// Run       : Run number
// Event     : Event number
// Eventb    : Sub-event number
// VetoLevel : Veto level indicator
// DetId     : Detector identifier
// Date      : The UTC observation date with as possible units "ddmmyyyy", "yyyymmdd", "mmddyyyy" or "yyyyddmm"
// Tobs      : The UTC observation c.q. trigger timestamp with as possible units "JD", "MJD", "TJD", "hms" or "hrs"
// Tstart    : Generic UTC start timestamp with as possible units "JD", "MJD", "TJD", "hms" or "hrs"
// Tend      : Generic UTC end timestamp with as possible units "JD", "MJD", "TJD", "hms" or "hrs"
// d         : Distance with a number as units (Standard unit is pc)
// a         : right ascension, longitude, azimuth angle or spherical angle theta (depending on the reference frame)
// b         : declination, latitude, zenith angle or spherical angle phi (depending on the reference frame)
// z         : Redshift
// E         : Energy with a number as units (Standard unit is GeV)
// L         : Luminosity with a number as units (Standard unit is erg s^-1. [For particle counts : s^-1])
// S         : Fluence with a number as units (Standard unit is erg cm^-2. [For particle counts : cm^-2])
// F         : Flux with a number as units (Standard unit is erg cm^-2 s^-1 [For particle counts : cm^-2 s^-1])
// I         : Intensity with a number as units (Standard unit is erg cm^-2 s^-1 sr^-1 [For particle counts : cm^-2 s^-1 sr^-1])
// J         : Flux density with a number as units (Standard unit is Jy, i.e. 1e-23 erg cm^-2 s^-1 Hz^-1)
// T90       : T90 burst duration with a number as units (Standard unit is second)
// T100      : T100 burst duration with a number as units (Standard unit is second)
// dsigma    : The on d
// csigma    : The angular uncertainty in a cone around the position or direction
// zsigma    : The uncertainty on z
// Esigma    : The uncertainty on E
// Lsigma    : The uncertainty on L
// Ssigma    : The uncertainty on S
// Fsigma    : The uncertainty on F
// Isigma    : The uncertainty on I
// T90sigma  : The uncertainty on T90 
// T100sigma : The uncertainty on T90 
//
// Note : In case Tobs, Tstart or Tend are specified in "hms" or "hrs", also Date has to be provided.
//
// Accepted specifications for units are :
// ---------------------------------------
// "1"   : Standard units are used like GeV, pc, second (or days in case of Julian Dates)
//         Any other numerical value will be used for unit conversion (see below for examples)
// "rad" : Angle provided in radians
// "deg" : Angle provided in degrees
// "dms" : Angle provided in dddmmss.sss
// "hms" : Angle or time provided in hhmmss.sss
// "hrs" : Angle or time provided in fractional hours
// "JD"  : Timestamp provided as Julian Date
// "MJD" : Timestamp provided as Modified Julian Date
// "TJD" : Timestamp provided as Truncated Julian Date
//
// Accepted specifications for func are :
// --------------------------------------
// "Log" : Log10 of the value of the corresponding observable
// "Ln"  : Natural logarithm of the value of the corresponding observable
//
// Input examples :
// ----------------
// ("E","Enu","1","Log")      : The ROOT Tree variable "Enu" represents Log10(energy) in GeV.
// ("Date","date","yyyymmdd") : The ROOT Tree variable "date" represents the date as yyyymmdd.
// ("Tstart","time","hms")    : The ROOT Tree variable "time" represents a timestamp as hhmmss.sss.
// ("d","dist","1e6")         : The ROOT Tree variable "dist" represents the distance in Mpc.
// ("Tobs","trig","MJD")      : The ROOT Tree variable "trig" represents the observation time in MJD.
//
// The defaults are units="1" and func="none".

Definition at line 11088 of file NcAstrolab.cxx.

SetEmatrix()

void NcAstrolab::SetEmatrix ( NcTimestamp * ts )

protected

// Set the mean equatorial to ecliptic coordinate conversion matrix
// for the specified timestamp.
// A nice sketch and explanation of the two frames can be found
// in chapter 3 of the book "Astronomy Methods" by Hale Bradt (2004).

Definition at line 4308 of file NcAstrolab.cxx.

SetExperiment()

void NcAstrolab::SetExperiment	(	TString	name,
		Int_t	id = 0 )

// Set position, local frame definition and time offset w.r.t. UT
// for a known experiment as specified via the arguments "name" and "id".
// The (optional) input argument "id" allows to specify a particular
// element of a larger experimental setup, like for instance a specific
// detector station of the RNO-G radio array.
// The value id=0 (which is the default) represents a global location,
// like for instance the center of the experiment (like for IceCube)
// or some generic location (like the Big House for RNO-G).
//
// Currently the supported experiment names are :
//
// User      : Virtual Lab for general use
// Greenwich : The Royal Observatory in the UK
// Amanda    : Antarctic Muon And Neutrino Detector Array at the South Pole
// IceCube   : The IceCube neutrino observatory at the South Pole
// WSRT      : The Westerbork Synthesis Radio Telescope in the Netherlands
// Astron    : The Netherlands Institute for Radio Astronomy in Dwingeloo
// ARA       : The Askaryan Radio Array at the South Pole
// RNO-G     : The Greenland Radio Neutrino Observatory at Summit Station
// ARCA      : The KM3NeT ARCA detector next to Sicily
//
// Notes :
// -------
// 1) The name and title for the NcAstrolab object are updated automatically
//    according to the specified experiment name at invokation of this memberfunction.
//    In case a different name and/or title is required, please use the usual
//    SetNameTitle facility after invokation of this memberfunction.
//
// 2) In case no detector identifiers have been defined for the specified experiment,
//    the identifier "id" will be set to 0.
//    For the experiment "User" the provided detector identifier (id) will always be set.
//    This allows full flexibility for a generic "User" lab.
//
// The default value is id=0.

Definition at line 822 of file NcAstrolab.cxx.

SetGmatrix()

void NcAstrolab::SetGmatrix ( TString mode )

protected

// Set the mean equatorial to galactic coordinate conversion matrix.
// The B1950 parameters were taken from section 22.3 of the book
// "An Introduction to Modern Astrophysics" by Carrol and Ostlie (1996).
// The J2000 parameters are obtained by precession of the B1950 values.
//
// Via the input argument "mode" the required epoch can be selected
// mode = "B" ==> B1950
//        "J" ==> J2000

Definition at line 4246 of file NcAstrolab.cxx.

SetHmatrix()

void NcAstrolab::SetHmatrix ( NcTimestamp * ts )

protected

// Set the mean equatorial to horizontal coordinate conversion matrix
// for the specified timestamp.
// A nice sketch and explanation of the two frames can be found
// in chapter 3 of the book "Astronomy Methods" by Hale Bradt (2004).
//
// Note : In order to simplify the calculations, we use here a
//        right-handed horizontal frame.

Definition at line 4337 of file NcAstrolab.cxx.

SetLabPosition() [1/2]

void NcAstrolab::SetLabPosition	(	Double_t	l,
		Double_t	b,
		TString	u = "deg" )

// Set the lab position in the terrestrial longitude (l) and latitude (b)
// and its corresponding time offset w.r.t. UT.
// Positions north of the equator have b>0, whereas b<0 indicates
// locations south of the equator.
// Positions east of the Greenwich reference meridian have l>0,
// whereas l<0 indicates locations west of the Greenwich reference meridian.
//
// In the default constructor, the lab has been located at the North Pole using UTC
// and the right handed local reference frame was given the following convention :
// X-axis pointing South (=Greenwich)
// Y-axis pointing East
// Z-axis pointing towards Zenith
//
// In other words : 
// The right handed position reference frame was defined such that the North Pole
// corresponds to a polar angle theta=0 and the Greenwich meridian corresponds
// to an azimuth angle phi=0, with phi increasing eastwards.
//
// See the memberfunction SetExperiment() for an automatic setting of the
// characteristics of several well known experimental sites.
//
// The string argument "u" allows to choose between different angular units
// u = "rad" : angles provided in radians
//     "deg" : angles provided in degrees
//     "dms" : angles provided in dddmmss.sss
//     "hms" : angles provided in hhmmss.sss
//
// The default is u="deg".

Definition at line 770 of file NcAstrolab.cxx.

SetLabPosition() [2/2]

void NcAstrolab::SetLabPosition

(

Nc3Vector &

r

)

// Set the lab position in the terrestrial coordinates and its corresponding
// time offset w.r.t. UT.
//
// In the default constructor, the lab has been located at the North Pole using UTC
// and the right handed local reference frame was given the following convention :
// X-axis pointing South (=Greenwich)
// Y-axis pointing East
// Z-axis pointing towards Zenith
//
// In other words : 
// The right handed position reference frame was defined such that the North Pole
// corresponds to a polar angle theta=0 and the Greenwich meridian corresponds
// to an azimuth angle phi=0, with phi increasing eastwards.
//
// See the memberfunction SetExperiment() for an automatic setting of the
// characteristics of several well known experimental sites.

Definition at line 738 of file NcAstrolab.cxx.

SetLabTimeOffset()

void NcAstrolab::SetLabTimeOffset

(

Double_t

dt

)

// Set the lab time offset (dt) w.r.t. UT in (fractional) hours.
// Normally one should not use this function, but set the time offset automatically 
// by invokation of the memberfunctions SetPosition() or SetExperiment().
// This memberfunction is meant to investigate (systematic) effects in the case
// of possible timing problems. 

Definition at line 1003 of file NcAstrolab.cxx.

SetLocalFrame()

void NcAstrolab::SetLocalFrame	(	Double_t	t1,
		Double_t	p1,
		Double_t	t2,
		Double_t	p2,
		Double_t	t3,
		Double_t	p3 )

// Specification of the orientations of the local reference frame axes.
// The input arguments represent the angles (in degrees) of the local-frame axes
// w.r.t. a so called Master Reference Frame (MRF).
//
// The right handed Master Reference Frame (MRF) is defined as follows :
//  Z-axis : Points to the local Zenith
//  X-axis : Makes an angle of 90 degrees with the Z-axis and points South
//  Y-axis : Makes an angle of 90 degrees with the Z-axis and points East
//
// The various input arguments are defined as follows :
// t1 : Theta (=Zenith) angle of the local X-axis in the MRF
// p1 : Phi angle of the local X-axis in the MRF
// t2 : Theta (=Zenith) angle of the local Y-axis in the MRF
// p2 : Phi angle of the local Y-axis in the MRF
// t3 : Theta (=Zenith) angle of the local Z-axis in the MRF
// p3 : Phi angle of the local Z-axis in the MRF
//
// Example :
// ---------
// The local frame is identical to the MRF when (t1,p1,t2,p2,t3,p3)=(90,0,90,90,0,0).
//
// Once the user has specified the local reference frame, any observed event
// can be related to astronomical space-time locations via the SetSignal
// and GetSignal memberfunctions.

Definition at line 4383 of file NcAstrolab.cxx.

SetLT() [1/10]

void NcTimestamp::SetLT	(	Double_t	dt,
		Int_t	y,
		Int_t	d,
		Int_t	s,
		Int_t	ns = 0,
		Int_t	ps = 0,
		TString	utc = "A",
		Int_t	leap = 0,
		Double_t	dut = 0 )

// Set the NcTimestamp parameters corresponding to the specified elapsed
// timespan since the beginning of the new LT year.
// This facility is exact upto picosecond precision and as such is
// for scientific observations preferable above the corresponding
// Set function(s) of TTimestamp.
// The latter has a random spread in the sub-second part, which
// might be of use in generating distinguishable timestamps while
// still keeping second precision.
// Optionally the user can also provide the corresponding UTC parameters 
// (i.e. cumulated number of Leap Seconds and dut=UT-UTC) to enable to report next 
// to UT also UTC and TAI derived time information.
// These UTC parameters will not affect the LT setting.
//
// The LT year and elapsed time span is entered via the following input arguments :
//
// dt   : the local time offset in fractional hours w.r.t. UT.
// y    : year in LT (e.g. 1952, 2003 etc...)
// d    : elapsed number of days 
// s    : (remaining) elapsed number of seconds
// ns   : (remaining) elapsed number of nanoseconds
// ps   : (remaining) elapsed number of picoseconds
// utc  : Flag to denote whether the UTC parameters "leap" and "dut" (see below) are provided or not.
//        "N" ==> No UTC parameters will be stored.
//                The TAI related time recording is disabled and the values of
//                the Leap Seconds and dut=UT-UTC will be set to zero.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//        "M" ==> Manual setting of the UTC parameters as specified by "leap" and "dut".
//        "A" ==> Automatic setting of the UTC parameters from the loaded IERS data files.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//                For further details see the memberfunction SetUTCparameters().
// leap : The accumulated number of Leap Seconds corresponding to this date/time.
// dut  : The monitored time difference UT-UTC in seconds.
//
// The value of UT-UTC is kept within 0.9 sec. by the introduction of Leap Seconds into UTC.
// An overview of the accumulated leap seconds is available at :
//                https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
//                     or  http://maia.usno.navy.mil/ser7/tai-utc.dat
// 
// The time difference dUT=UT-UTC is monitored on a daily basis and the data are available at :
//                 https://hpiers.obspm.fr/iers/series/opa/eopc04
//                     or  http://maia.usno.navy.mil/ser7/ser7.dat
//
// The accuracy of the dUT=UT-UTC monitoring is about 10 microseconds.
//
// Notes :
// -------
// 1) In case of invalid input arguments the TAI related time recording is disabled
//    and the values of the Leap Seconds and dut=UT-UTC will be set to zero.
// 2) In case utc="A" and no data files have been loaded, or no information is available,
//    the utc="N" mode will be invoked.
//
// The specified d, s, ns and ps values will be used in an additive
// way to determine the elapsed timespan.
// So, specification of d=1, s=100, ns=0, ps=0 will result in the
// same elapsed time span as d=0, s=24*3600+100, ns=0, ps=0.
// However, by making use of the latter the user should take care
// of possible integer overflow problems in the input arguments,
// which obviously will provide incorrect results. 
//
// Note : ns=0, ps=0, utc="A", leap=0 and dut=0 are the default values.
//
// This facility first sets the UT as specified by the input arguments
// and then corrects the UT by subtracting the local time offset w.r.t. UT.
// As such this facility is valid for all AD dates in the Gregorian calendar.

Definition at line 100 of file NcTimestamp.cxx.

SetLT() [2/10]

void NcTimestamp::SetLT	(	Double_t	dt,
		Int_t	y,
		Int_t	m,
		Int_t	d,
		Int_t	hh,
		Int_t	mm,
		Double_t	s,
		TString	utc = "A",
		Int_t	leap = 0,
		Double_t	dut = 0 )

// Set the NcTimestamp parameters corresponding to the LT date and time
// in the Gregorian calendar as specified by the input arguments.
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
// Optionally the user can also provide the corresponding UTC parameters 
// (i.e. cumulated number of Leap Seconds and dut=UT-UTC) to enable to report next 
// to UT also UTC and TAI derived time information.
// These UTC parameters will not affect the LT setting.
//
// The input arguments represent the following :
// dt   : the local time offset in fractional hours w.r.t. UT
// y    : year in LT (e.g. 1952, 2003 etc...)
// m    : month in LT (1=jan  2=feb etc...)
// d    : day in LT (1-31)
// hh   : elapsed hours in LT (0-23) 
// mm   : elapsed minutes in LT (0-59)
// s    : elapsed (fractional) seconds in LT (0-59.999...)
// utc  : Flag to denote whether the UTC parameters "leap" and "dut" (see below) are provided or not.
//        "N" ==> No UTC parameters will be stored.
//                The TAI related time recording is disabled and the values of
//                the Leap Seconds and dut=UT-UTC will be set to zero.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//        "M" ==> Manual setting of the UTC parameters as specified by "leap" and "dut".
//        "A" ==> Automatic setting of the UTC parameters from the loaded IERS data files.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//                For further details see the memberfunction SetUTCparameters().
// leap : The accumulated number of Leap Seconds corresponding to this date/time.
// dut  : The monitored time difference UT-UTC in seconds.
//
// The value of UT-UTC is kept within 0.9 sec. by the introduction of Leap Seconds into UTC.
// An overview of the accumulated leap seconds is available at :
//                https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
//                     or  http://maia.usno.navy.mil/ser7/tai-utc.dat
// 
// The time difference dUT=UT-UTC is monitored on a daily basis and the data are available at :
//                 https://hpiers.obspm.fr/iers/series/opa/eopc04
//                     or  http://maia.usno.navy.mil/ser7/ser7.dat
//
// The accuracy of the dUT=UT-UTC monitoring is about 10 microseconds.
//
// Notes :
// -------
// 1) In case of invalid input arguments the TAI related time recording is disabled
//    and the values of the Leap Seconds and dut=UT-UTC will be set to zero.
// 2) In case utc="A" and no data files have been loaded, or no information is available,
//    the utc="N" mode will be invoked.
//
// The default values are utc="A", leap=0 and dut=0.
//
// This facility first sets the UT as specified by the input arguments
// and then corrects the UT by subtracting the local time offset w.r.t. UT.
// As such this facility is valid for all AD dates in the Gregorian calendar.

Definition at line 97 of file NcTimestamp.cxx.

SetLT() [3/10]

void NcTimestamp::SetLT	(	Double_t	dt,
		Int_t	y,
		Int_t	m,
		Int_t	d,
		Int_t	hh,
		Int_t	mm,
		Int_t	ss,
		Int_t	ns = 0,
		Int_t	ps = 0,
		TString	utc = "A",
		Int_t	leap = 0,
		Double_t	dut = 0 )

// Set the NcTimestamp parameters corresponding to the LT date and time
// in the Gregorian calendar as specified by the input arguments.
// This facility is exact upto picosecond precision and as such is
// for scientific observations preferable above the corresponding
// Set function(s) of TTimestamp.
// The latter has a random spread in the sub-second part, which
// might be of use in generating distinguishable timestamps while
// still keeping second precision.
// Optionally the user can also provide the corresponding UTC parameters 
// (i.e. cumulated number of Leap Seconds and dut=UT-UTC) to enable to report next 
// to UT also UTC and TAI derived time information.
// These UTC parameters will not affect the LT setting.
//
// The input arguments represent the following :
//
// dt   : the local time offset in fractional hours w.r.t. UT.
// y    : year in LT (e.g. 1952, 2003 etc...)
// m    : month in LT (1=jan  2=feb etc...)
// d    : day in LT (1-31)
// hh   : elapsed hours in LT (0-23) 
// mm   : elapsed minutes in LT (0-59)
// ss   : elapsed seconds in LT (0-59)
// ns   : remaining fractional elapsed second of LT in nanosecond
// ps   : remaining fractional elapsed nanosecond of LT in picosecond
// utc  : Flag to denote whether the UTC parameters "leap" and "dut" (see below) are provided or not.
//        "N" ==> No UTC parameters will be stored.
//                The TAI related time recording is disabled and the values of
//                the Leap Seconds and dut=UT-UTC will be set to zero.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//        "M" ==> Manual setting of the UTC parameters as specified by "leap" and "dut".
//        "A" ==> Automatic setting of the UTC parameters from the loaded IERS data files.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//                For further details see the memberfunction SetUTCparameters().
// leap : The accumulated number of Leap Seconds corresponding to this date/time.
// dut  : The monitored time difference UT-UTC in seconds.
//
// The value of UT-UTC is kept within 0.9 sec. by the introduction of Leap Seconds into UTC.
// An overview of the accumulated leap seconds is available at :
//                https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
//                     or  http://maia.usno.navy.mil/ser7/tai-utc.dat
// 
// The time difference dUT=UT-UTC is monitored on a daily basis and the data are available at :
//                 https://hpiers.obspm.fr/iers/series/opa/eopc04
//                     or  http://maia.usno.navy.mil/ser7/ser7.dat
//
// The accuracy of the dUT=UT-UTC monitoring is about 10 microseconds.
//
// Notes :
// -------
// 1) In case of invalid input arguments the TAI related time recording is disabled
//    and the values of the Leap Seconds and dut=UT-UTC will be set to zero.
// 2) In case utc="A" and no data files have been loaded, or no information is available,
//    the utc="N" mode will be invoked.
//
// The default values are ns=0, ps=0, utc="A", leap=0 and dut=0.
//
// This facility first sets the UT as specified by the input arguments
// and then corrects the UT by subtracting the local time offset w.r.t. UT.
// As such this facility is valid for all AD dates in the Gregorian
// calendar with picosecond precision.

Definition at line 96 of file NcTimestamp.cxx.

SetLT() [4/10]

void NcTimestamp::SetLT	(	Double_t	dt,
		Int_t	y,
		Int_t	m,
		Int_t	d,
		TString	time,
		TString	utc = "A",
		Int_t	leap = 0,
		Double_t	dut = 0 )

// Set the NcTimestamp parameters corresponding to the LT date and time
// in the Gregorian calendar as specified by the input arguments.
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
// Optionally the user can also provide the corresponding UTC parameters 
// (i.e. cumulated number of Leap Seconds and dut=UT-UTC) to enable to report next 
// to UT also UTC and TAI derived time information.
// These UTC parameters will not affect the LT setting.
//
// The input arguments represent the following :
// dt   : the local time offset in fractional hours w.r.t. UT
// y    : year in LT (e.g. 1952, 2003 etc...)
// m    : month in LT (1=jan  2=feb etc...)
// d    : day in LT (1-31)
// time : The LT time in the format hh:mm:ss.sss
// utc  : Flag to denote whether the UTC parameters "leap" and "dut" (see below) are provided or not.
//        "N" ==> No UTC parameters will be stored.
//                The TAI related time recording is disabled and the values of
//                the Leap Seconds and dut=UT-UTC will be set to zero.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//        "M" ==> Manual setting of the UTC parameters as specified by "leap" and "dut".
//        "A" ==> Automatic setting of the UTC parameters from the loaded IERS data files.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//                For further details see the memberfunction SetUTCparameters().
// leap : The accumulated number of Leap Seconds corresponding to this date/time.
// dut  : The monitored time difference UT-UTC in seconds.
//
// The value of UT-UTC is kept within 0.9 sec. by the introduction of Leap Seconds into UTC.
// An overview of the accumulated leap seconds is available at :
//                https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
//                     or  http://maia.usno.navy.mil/ser7/tai-utc.dat
// 
// The time difference dUT=UT-UTC is monitored on a daily basis and the data are available at :
//                 https://hpiers.obspm.fr/iers/series/opa/eopc04
//                     or  http://maia.usno.navy.mil/ser7/ser7.dat
//
// The accuracy of the dUT=UT-UTC monitoring is about 10 microseconds.
//
// Notes :
// -------
// 1) In case of invalid input arguments the TAI related time recording is disabled
//    and the values of the Leap Seconds and dut=UT-UTC will be set to zero.
// 2) In case utc="A" and no data files have been loaded, or no information is available,
//    the utc="N" mode will be invoked.
//
// The default values are utc="A", leap=0 and dut=0.
//
// This facility first sets the UT as specified by the input arguments
// and then corrects the UT by subtracting the local time offset w.r.t. UT.
// As such this facility is valid for all AD dates in the Gregorian calendar.

Definition at line 98 of file NcTimestamp.cxx.

SetLT() [5/10]

void NcTimestamp::SetLT	(	Double_t	dt,
		TString	date,
		TString	time,
		Int_t	mode,
		TString	utc = "A",
		Int_t	leap = 0,
		Double_t	dut = 0 )

// Set the NcTimestamp parameters corresponding to the LT date and time
// in the Gregorian calendar as specified by the input arguments.
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
// Optionally the user can also provide the corresponding UTC parameters 
// (i.e. cumulated number of Leap Seconds and dut=UT-UTC) to enable to report next 
// to UT also UTC and TAI derived time information.
// These UTC parameters will not affect the LT setting.
//
// The input arguments represent the following :
// dt   : the local time offset in fractional hours w.r.t. UT
// date : The LT date in the format dd-mm-yyyy or dd/mm/yyyy or ddmmyyyy (mode=0)
// date : The LT date in the format yyyy-mm-dd or yyyy/mm/dd or yyyymmdd (mode=1)
// date : The LT date in the format mm-dd-yyyy or mm/dd/yyyy or mmddyyyy (mode=2)
// date : The LT date in the format yyyy-dd-mm or yyyy/dd/mm or yyyyddmm (mode=3)
// time : The LT time in the format hh:mm:ss.sss
// mode : Date format specifier (see above)
// utc  : Flag to denote whether the UTC parameters "leap" and "dut" (see below) are provided or not.
//        "N" ==> No UTC parameters will be stored.
//                The TAI related time recording is disabled and the values of
//                the Leap Seconds and dut=UT-UTC will be set to zero.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//        "M" ==> Manual setting of the UTC parameters as specified by "leap" and "dut".
//        "A" ==> Automatic setting of the UTC parameters from the loaded IERS data files.
//                In this case the specified values of "leap" and "dut" are irrelevant.
//                For further details see the memberfunction SetUTCparameters().
// leap : The accumulated number of Leap Seconds corresponding to this date/time.
// dut  : The monitored time difference UT-UTC in seconds.
//
// The value of UT-UTC is kept within 0.9 sec. by the introduction of Leap Seconds into UTC.
// An overview of the accumulated leap seconds is available at :
//                https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
//                     or  http://maia.usno.navy.mil/ser7/tai-utc.dat
// 
// The time difference dUT=UT-UTC is monitored on a daily basis and the data are available at :
//                 https://hpiers.obspm.fr/iers/series/opa/eopc04
//                     or  http://maia.usno.navy.mil/ser7/ser7.dat
//
// The accuracy of the dUT=UT-UTC monitoring is about 10 microseconds.
//
// Notes :
// -------
// 1) In case of invalid input arguments the TAI related time recording is disabled
//    and the values of the Leap Seconds and dut=UT-UTC will be set to zero.
// 2) In case utc="A" and no data files have been loaded, or no information is available,
//    the utc="N" mode will be invoked.
//
// The default values are utc="A", leap=0 and dut=0.
//
// This facility first sets the UT as specified by the input arguments
// and then corrects the UT by subtracting the local time offset w.r.t. UT.
// As such this facility is valid for all AD dates in the Gregorian calendar.

Definition at line 99 of file NcTimestamp.cxx.

SetLT() [6/10]

void NcAstrolab::SetLT	(	Int_t	y,
		Int_t	d,
		Int_t	s,
		Int_t	ns = 0,
		Int_t	ps = 0 )

// Set the NcTimestamp parameters corresponding to the specified elapsed
// timespan since the beginning of the new LT year.
//
// The LT year and elapsed time span is entered via the following input arguments :
//
// y  : year in LT (e.g. 1952, 2003 etc...)
// d  : elapsed number of days 
// s  : (remaining) elapsed number of seconds
// ns : (remaining) elapsed number of nanoseconds
// ps : (remaining) elapsed number of picoseconds
//
// The specified d, s, ns and ps values will be used in an additive
// way to determine the elapsed timespan.
// So, specification of d=1, s=100, ns=0, ps=0 will result in the
// same elapsed time span as d=0, s=24*3600+100, ns=0, ps=0.
// However, by making use of the latter the user should take care
// of possible integer overflow problems in the input arguments,
// which obviously will provide incorrect results. 
//
// Note : ns=0 and ps=0 are the default values.

Definition at line 4781 of file NcAstrolab.cxx.

SetLT() [7/10]

void NcAstrolab::SetLT	(	Int_t	y,
		Int_t	m,
		Int_t	d,
		Int_t	hh,
		Int_t	mm,
		Double_t	s )

// Set the NcTimestamp parameters corresponding to the (mean) local date and time (LT)
// in the Gregorian calendar as specified by the input arguments.
// This facility is valid for all AD dates in the Gregorian calendar.
//
// Note : One should NOT use Daylight Saving Time (DST) 
//
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
//
// The input arguments represent the following :
// y  : year in LT (e.g. 1952, 2003 etc...)
// m  : month in LT (1=jan  2=feb etc...)
// d  : day in LT (1-31)
// hh : elapsed hours in LT (0-23) 
// mm : elapsed minutes in LT (0-59)
// s  : elapsed (fractional) seconds in LT (0-59.999...)

Definition at line 4705 of file NcAstrolab.cxx.

SetLT() [8/10]

void NcAstrolab::SetLT	(	Int_t	y,
		Int_t	m,
		Int_t	d,
		Int_t	hh,
		Int_t	mm,
		Int_t	ss,
		Int_t	ns = 0,
		Int_t	ps = 0 )

// Set the NcTimestamp parameters corresponding to the (mean) local date and time (LT)
// in the Gregorian calendar as specified by the input arguments.
// This facility is valid for all AD dates in the Gregorian calendar.
//
// Note : One should NOT use Daylight Saving Time (DST) 
//
// The input arguments represent the following :
// y  : year in LT (e.g. 1952, 2003 etc...)
// m  : month in LT (1=jan  2=feb etc...)
// d  : day in LT (1-31)
// hh : elapsed hours in LT (0-23) 
// mm : elapsed minutes in LT (0-59)
// ss : elapsed seconds in LT (0-59)
// ns : remaining fractional elapsed second of LT in nanosecond
// ps : remaining fractional elapsed nanosecond of LT in picosecond
//
// Note : ns=0 and ps=0 are the default values.

Definition at line 4678 of file NcAstrolab.cxx.

SetLT() [9/10]

void NcAstrolab::SetLT	(	Int_t	y,
		Int_t	m,
		Int_t	d,
		TString	time )

// Set the NcTimestamp parameters corresponding to the (mean) local date and time (LT)
// in the Gregorian calendar as specified by the input arguments.
// This facility is valid for all AD dates in the Gregorian calendar.
//
// Note : One should NOT use Daylight Saving Time (DST) 
//
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
//
// The input arguments represent the following :
// y    : year in LT (e.g. 1952, 2003 etc...)
// m    : month in LT (1=jan  2=feb etc...)
// d    : day in LT (1-31)
// time : The LT time in the format hh:mm:ss.sss

Definition at line 4731 of file NcAstrolab.cxx.

SetLT() [10/10]

void NcAstrolab::SetLT	(	TString	date,
		TString	time,
		Int_t	mode )

// Set the NcTimestamp parameters corresponding to the (mean) local date and time (LT)
// in the Gregorian calendar as specified by the input arguments.
// This facility is valid for all AD dates in the Gregorian calendar.
//
// Note : One should NOT use Daylight Saving Time (DST) 
//
// Due to rounding errors the highest (i.e. picosecond) accuracy might not be reached.
// For a guaranteed picosecond precision please refer to the other SetLT() memberfunctions.
//
// The input arguments represent the following :
// date : The LT date in the format dd-mm-yyyy or dd/mm/yyyy or ddmmyyyy (mode=0)
// date : The LT date in the format yyyy-mm-dd or yyyy/mm/dd or yyyymmdd (mode=1)
// date : The LT date in the format mm-dd-yyyy or mm/dd/yyyy or mmddyyyy (mode=2)
// date : The LT date in the format yyyy-dd-mm or yyyy/dd/mm or yyyyddmm (mode=3)
// time : The LT time in the format hh:mm:ss.sss
// mode : Date format specifier (see above)

Definition at line 4755 of file NcAstrolab.cxx.

SetMapTS()

void NcAstrolab::SetMapTS ( )

protected

// Internal memberfunction to compose the timestamp within the SkyMapPanel GUI.

Definition at line 19206 of file NcAstrolab.cxx.

SetMarkerColor()

void NcAstrolab::SetMarkerColor	(	Int_t	color,
		Int_t	type )

// Set the color of the marker symbols for skymaps and related histograms.
// Defaults are set in the constructor of this NcAstrolab class. 
//
// type = 0 --> Set marker color for reference signals    (default=kRed)
//        1 --> Set marker color for measurements         (default=kBlue)
//        2 --> Set marker color for the Galactic Center  (default=kBlack)
//        3 --> Set marker color for the skymap grid dots (default=kBlack)

Definition at line 7327 of file NcAstrolab.cxx.

SetMarkerSize()

void NcAstrolab::SetMarkerSize	(	Float_t	size,
		Int_t	type )

// Set the size of the marker symbols for skymaps and related histograms.
// Defaults are set in the constructor of this NcAstrolab class. 
//
// type = 0 --> Set marker size for reference signals    (default=1.5)
//        1 --> Set marker size for measurements         (default=1.0)
//        2 --> Set marker size for the Galactic Center  (default=1.5)
//        3 --> Set marker size for the skymap grid dots (default=0.3)

Definition at line 7289 of file NcAstrolab.cxx.

SetMarkerStyle()

void NcAstrolab::SetMarkerStyle	(	Int_t	style,
		Int_t	type )

// Set the style of the marker symbols for skymaps and related histograms.
// Defaults are set in the constructor of this NcAstrolab class. 
//
// type = 0 --> Set marker style for reference signals    (default=29 filled star)
//        1 --> Set marker style for measurements         (default=8  scalable dot)
//        2 --> Set marker style for the Galactic Center  (default=34 filled cross)
//        3 --> Set marker style for the skymap grid dots (default=8  scalable dot)

Definition at line 7308 of file NcAstrolab.cxx.

SetMaxDt()

void NcAstrolab::SetMaxDt

(

Double_t

s

)

// Set the maximum time difference (in sec) for returning a timestamp related
// (reference) signal via GetSignal.
//
// Note : In case s<0 no check on the timestamps will be performed and a signal
//        is always returned.
//        
// In the default constructor s=-1 is set. 

Definition at line 1174 of file NcAstrolab.cxx.

SetNmatrix()

void NcAstrolab::SetNmatrix ( NcTimestamp * ts )

protected

// Set nutation matrix elements for the specified Julian date jd.
// The formulas and numerical constants used are the ones from the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.

Definition at line 4198 of file NcAstrolab.cxx.

SetPhysicalParameter()

void NcAstrolab::SetPhysicalParameter	(	TString	name,
		Double_t	value )

// Facility to modify the value of a physical parameter.
// In the constructor of this class the various parameters have been
// set to the values as provided by the Particle Data Group in 2014.
//
// The parameter is specified via the input argument "name".
// Currently the following parameters are supported :
//
// SpeedC  = The speed of light in vacuum in m/s
// Qe      = The electron charge in C
// Me      = The electron mass in MeV/c^2
// Mmu     = The muon mass in MeV/c^2
// Mtau    = The tau mass in MeV/c^2
// Amu     = The unified atomic mass unit in MeV/c^2
// Mp      = The proton mass in MeV/c^2
// Mn      = The neutron mass in MeV/c^2 
// AlphaEM = The electromagnetic fine-structure constant
// Fermi   = The Fermi coupling constant GF/(hbar*c)^3 in GeV^-2
// MW      = The W mass in GeV/c^2
// GammaW  = Full width of W in GeV
// MZ      = The Z mass in GeV/c^2 
// GammaZ  = Full width of Z in GeV
// Planck  = The value of the Planck constant (h) in J s
// Boltz   = The value of the Boltzmann constant (k) in J K^-1
// Newton  = The Newton gravitational constant in m^3 kg^-1 s^-1
// Gn      = The nominal value of the gravitational acceleration at the Earth surface in m s^-2
// Au      = The astronomical unit in m
// Pc      = The parsec in m
// Hubble  = The Hubble parameter in km s^-1 Mpc^-1
// OmegaM  = The fractional mass energy density
// OmegaR  = The fractional radiation energy density
// OmegaL  = The fractional vacuum energy density
// OmegaB  = The fractional baryon energy density
// OmegaC  = The fractional cold dark matter energy density

Definition at line 7536 of file NcAstrolab.cxx.

SetPmatrix()

void NcAstrolab::SetPmatrix ( NcTimestamp * ts )

protected

// Set precession matrix elements for Julian date jd w.r.t. J2000.
// The formulas and numerical constants used are the ones from the 
// U.S. Naval Observatory (USNO) circular 179 (2005), which is available on
// http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
// All numerical constants refer to the standard reference epoch J2000.

Definition at line 4138 of file NcAstrolab.cxx.

SetPositionScramble()

void NcAstrolab::SetPositionScramble	(	Int_t	mode,
		Double_t	dmin,
		Double_t	dmax,
		TF1 *	df = 0,
		Double_t	thmin = 0,
		Double_t	thmax = 0,
		TF1 *	thf = 0,
		Double_t	phimin = 0,
		Double_t	phimax = 0,
		TF1 *	phif = 0 )

// Set parameters for position scrambling of the measurements in local coordinates.
// This scrambling facility is very useful for studying (accidental) background
// correlations and performing blind analyses.
//
// mode   : Mode for performing the position scrambling (see below)
// dmin   : Minimal value for scrambling angular difference (in degrees) or vector length 
// dmax   : Maximal value for scrambling angular difference (in degrees) or vector length
// df     : Randomisation function for angular difference (or vector length) scrambling
// thmin  : Minimal value (in degrees) for scrambling local theta coordinate
// thmax  : Maximal value (in degrees) for scrambling local theta coordinate
// thf    : Randomisation function for local theta coordinate scrambling
// phimin : Minimal value (in degrees) for scrambling local phi coordinate
// phimax : Maximal value (in degrees) for scrambling local phi coordinate
// phif   : Randomisation function for local phi coordinate scrambling
//
// Conventions for the mode parameter :
// ------------------------------------
// mode : 0 ==> No position scrambling is performed.
//        1 ==> Scrambling is only performed when obtaining angular differences.
//              All angular differences are randomly selected from the interval [dmin,dmax].
//              If for this mode dmin<0 it will be set to 0 and if dmax>180 it will be set to 180.
//              This scrambling mode is very useful for scrambling entries within a specific angular range
//              w.r.t. a source (see e.g. NvE, Astroparticle Physics 28 (2008) 540), without modification of
//              the event selection based on the time difference w.r.t. a transient source.
//              This angular difference scrambling will only affect the outcome of the memberfunctions
//              GetDifference(), MatchRefSignal(), MatchSignals() and MatchBurstData() of this class NcAstrolab.
//              So, the actual (stored) event positions are not affected by the scrambling.
//              This implies that setting mode=0 will reproduce again the unscrambled values.
//              Note : Every time an angular difference is requested, a new random value is produced.
//                     As such, scrambled values are not reproducible on subsequent invokations.
//        2 ==> Position scrambling is performed on the local spherical coordinates before storing the measurement.
//              A value is randomly selected from the intervals [dmin,dmax], [thmin,thmax] and [phimin,phimax]
//              and added to the actual local spherical coordinates (r,theta,phi) of the measurement.
//              As such, this scrambling is irreversible but will always provide reproducible results.
//              Notes :
//              This mode=2 scrambling will also result in a corresponding scrambling of e.g. the right ascension.
//              In case the r-coordinate would become zero or negative by the scrambling, its value will be
//              set to a small positive value before storage, in order to keep a physical situation.
//        3 ==> Position scrambling is performed by using a fake local position of the measurement.
//              To create the fake measurement position, a value is randomly selected from the intervals
//              [dmin,dmax], [thmin,thmax] and [phimin,phimax] and added to the actual local spherical coordinates
//              (r,theta,phi) of the measurement.
//              Since the timestamp of the measurement is not modified, this mode=3 scrambling will also result
//              in a corresponding scrambling of e.g. the right ascension.
//              In case the r-coordinate would become zero or negative by the scrambling, its value will be
//              set to a small positive value before storage, in order to keep a physical situation.
//              This position scrambling will only affect the outcome of the memberfunctions
//              GetDifference(), MatchRefSignal(), MatchSignals() and MatchBurstData() of this class NcAstrolab.
//              So, the actual (stored) event positions are not affected by the scrambling.
//              This implies that setting mode=0 will reproduce again the unscrambled values.
//              Note : Every time an angular difference is requested, a new random value is produced.
//                     As such, scrambled values are not reproducible on subsequent invokations.
//       <0 ==> Similar as the corresponding mode>0, but the scrambling is only performed to obtain
//              the off-source background data in the memberfunction MatchBurstData().
//              So, the actual on-source recordings are not affected.  
//              Furthermore, for mode=-2 the scrambled positions are only used after retrieving the measurement
//              data from the storage, so the actual stored measurement data are not modified.   
//              This implies that for position scrambling mode=-2 is equivalent to mode=-3.
//
// Notes :
// -------
// In case df=0 the corresponding scrambling will be performed via a homogeneous solid angle (mode=1) or uniform (mode=2) distribution.
// In case thf=0 the corresponding mode=2 scrambling will be performed via a uniform distribution in cos(theta).
// In case phif=0 the corresponding mode=2 scrambling will be performed via a uniform distribution in phi.
//
// If the provided "max" value is smaller than the provided "min" value, both values are set equal
// to the "min" value. This is the preferred way to study specific angular c.q. distance offsets without
// running into computer accuracy problems. 
//
// The defaults are df=0, thmin=0, thmax=0, thf=0, phimin=0, phimax=0 and phif=0.
//
// In the NcAstrolab constructor the position scrambling is switched off
// by setting mode=0 explicitly.

Definition at line 5946 of file NcAstrolab.cxx.

SetRandomiser()

void NcAstrolab::SetRandomiser	(	Int_t	iseed,
		Int_t	cnt1 = 0,
		Int_t	cnt2 = 0,
		NcTimestamp *	ts = 0 )

// (Re)initialise the internal NcRandom randomisation facility.
//
// Note :
// ------
// This member function provides the user a handle to (re)initialise the internal randomisation
// facility in order to obtain reproducible scrambled results or to define unique random sequences
// for various NcAstrolab instances.
// If not initialised by the user, the randomisation facility is internally automatically "date/time driven"
// initialised by the actual timestamp of the moment the first need for a randomisation arises.
// This will ensure different random sequences for different NcAstrolab instances (if created at least 0.01 sec. apart),
// even in the case of identical stored measurements and reference signals.
// For details about the atomatically generated seed value please refer to the NcRandom documentation.
//
// So, in case there is no need for reproducible scrambled results among NcAstrolab instances that are created
// at time intervals of more than 0.01 second, the user is advised NOT to invoke this member function.
//
// Input arguments :
// -----------------
// iseed >= 0 --> Use this value as seed for the internal NcRandom object and start the
//                random sequence at the point defined by the counters "cnt1" and "cnt2".
//                In this case the timestamp "ts" is irrelevant.
//                For allowed seed values and info on the parameters "cnt1" and "cnt2"
//                please refer to the docs of NcRandom.
//       < 0  --> Use the provided NcTimestamp "ts" to generate a seed for the internal NcRandom object.
//                If ts=0 the current timestamp of this NcAstrolab instance is used.
//                The values of "cnt1" and "cnt2" are irrelevant, since the random sequence will always
//                be started from scratch.
//
// Note :
// ------
// Reproducible scrambled results among different NcAstrolab instances is only possible if they are
// all initialised with the same parameters for the internal randomiser.
// This implies that when initialisation is performed via a timestamp, this timestamp should be the
// same for all the corresponding NcAstrolab instances. This can be obtained via an explicit SetUT()
// invokation of the provided timestamp or NcAstrolab instance.
// By providing a specific iseed>=0 (and optionally "cnt1" and "cnt2") for all NcAstrolab instances,
// reproducibility is automatically obtained if the stored signals are identical.
//
// The default values are cnt1=0, cnt2=0 and ts=0.

Definition at line 1096 of file NcAstrolab.cxx.

SetSignal() [1/3]

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 = "T",
		TString	name = "",
		Int_t	type = 0 )

// Store a signal as specified by the distance d, angular position (a,b) and the timestamp ts.
// The pointer to the stored signal is returned (0 in case of incompatible data).
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the input argument "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation can be specified here and retrieved later.
// The position is stored in International Celestial Reference System (ICRS) coordinates.
// The ICRS is a fixed, time independent frame and as such provides a unique reference
// frame without the need of specifying any epoch etc...
// The ICRS coordinate definitions match within 20 mas with the mean ones of the J2000.0
// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
// coordinate correction between J2000 and ICRS is performed here via the
// so-called frame bias matrix.
// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
// which is available on http://aa.usno.navy.mil/publications/docs/Circular_179.pdf.
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : input angle provided in radians
//          "deg" : input angle provided in degrees
//          "dms" : input angle provided in dddmmss.sss
//          "hms" : input angle provided in hhmmss.sss
//          "hrs" : input angle provided in fractional hours
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ"  ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal"  ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl"  ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor"  ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr"  ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc"  ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//          "pdir" ==> Particle momentum direction at the NcAstrolab location in local coordinates theta (a) and phi (b).
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the input in case of equatorial (a,b) coordinates.
//
// mode = "M" --> Input coordinates are the mean values 
//        "T" --> Input coordinates are the true values
//        "B" --> Besselian (B1950) reference epoch coordinates 
//        "J" --> Julian (J2000) reference epoch coordinates 
//
// The input parameters "jref" and "type" allow the user to store measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Storage of a signal at the j-th position (j=1 is first)
//      < 0 --> Add a signal at the next available position
//
// type = 0 --> The entered data is a reference signal
//        1 --> The entered data is a measured signal
//
// Note : For backward compatibility jref=0 invokes the storage of a single measurement.
//        When invoked with jref=0 all other stored measurements will be lost.
//        However, the stored reference signals are not affected.
//        The user is advised not to use this obsolete jref=0 facility anymore. 
//
// Via the input argument "name" the user can give the stored signal also a name.
//
// The default values are mode="T", name="" and type=0.
//
// Notes :
// -------
// 1) In case ts=0 the current timestamp of the lab will be taken.
// 2) In case scrambling has been activated, the data will be scrambled accordingly.

Definition at line 1917 of file NcAstrolab.cxx.

SetSignal() [2/3]

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 = 0 )

// Store a signal as specified by the distance d, angular position (a,b) and the specified epoch.
// The pointer to the stored signal is returned (0 in case of incompatible data).
// For angular celestial positions it is quite common to use unit vectors, i.e. d=1.
// However, via the input argument "d" an actual distance, redshift, Lorentz factor or any other
// positive scalar observable related to the observation can be specified here and retrieved later.
// The position is stored in International Celestial Reference System (ICRS) coordinates.
// The ICRS is a fixed, time independent frame and as such provides a unique reference
// frame without the need of specifying any epoch etc...
// The ICRS coordinate definitions match within 20 mas with the mean ones of the J2000.0
// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
// coordinate correction between J2000 and ICRS is performed here via the
// so-called frame bias matrix.
// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
// which is available on http://aa.usno,navy.mil/publications/docs/Circular_179.pdf.
//
// The string input arguments "au" and "bu" allow the user to specifiy the units in which
// the angular coordinates "a" and "b" are provided. The convention is the following :
//
// string = "rad" : input angle provided in radians
//          "deg" : input angle provided in degrees
//          "dms" : input angle provided in dddmmss.sss
//          "hms" : input angle provided in hhmmss.sss
//          "hrs" : input angle provided in fractional hours
//
// The input parameter "frame" allows the user to specify the frame to which
// the angular coordinates (a,b) refer. Available options are :
//
//  frame = "equ"  ==> Equatorial coordinates with right ascension (a) and declination (b).
//          "gal"  ==> Galactic coordinates with longitude (a) and latitude (b).
//          "ecl"  ==> Geocentric ecliptic coordinates with longitude (a) and latitude (b).
//          "hor"  ==> Horizontal coordinates at the NcAstrolab location, with azimuth angle (a) and zenith angle (b).
//          "icr"  ==> ICRS coordinates with longitude (a) and latitude (b).
//          "loc"  ==> Local coordinates at the NcAstrolab location, with usual spherical angles theta (a) and phi (b).
//          "pdir" ==> Particle momentum direction at the NcAstrolab location in local coordinates theta (a) and phi (b).
//
// The time of the observation is specified by the following epoch input arguments :
//
//  s = "B" --> Besselian reference epoch.
//      "J" --> Julian reference epoch.
//  e : (Fractional) epoch to specify the timestamp of the observation (e.g. 1952.004353 or 2003.80953216)
//
// In case the coordinates are the equatorial right ascension and declination (a,b),
// they can represent so-called "mean", "true" or reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,b) are only corrected for precession and not for nutation
// true values  : (a,b) are corrected for both precession and nutation
// epoch values : (a,b) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the input in case of equatorial (a,b) coordinates.
//
// mode = "M" --> Input coordinates are the mean values 
//        "T" --> Input coordinates are the true values 
//        "B" --> Besselian (B1950) reference epoch coordinates 
//        "J" --> Julian (J2000) reference epoch coordinates 
//
// The input parameters "jref" and "type" allow the user to store measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Storage of a signal at the j-th position (j=1 is first)
//      < 0 --> Add a signal at the next available position
//
// type = 0 --> The entered data is a reference signal
//        1 --> The entered data is a measured signal
//
// Note : For backward compatibility jref=0 invokes the storage of a single measurement.
//        When invoked with jref=0 all other stored measurements will be lost.
//        However, the stored reference signals are not affected.
//        The user is advised not to use this obsolete jref=0 facility anymore. 
//
// Via the input argument "name" the user can give the stored signal also a name.
//
// The default values are name="" and type=0.
//
// Note : In case scrambling has been activated, the data will be scrambled accordingly.

Definition at line 2067 of file NcAstrolab.cxx.

SetSignal() [3/3]

NcSignal * NcAstrolab::SetSignal ( Nc3Vector * r, TString frame, TString mode, NcTimestamp * ts, Int_t jref, TString name, Int_t type )

protected

// Internal memberfunction for generic storage of a signal as specified by the position r and the timestamp ts.
// The pointer to the stored signal is returned (0 in case of incompatible data).
// The position is stored in International Celestial Reference System (ICRS) coordinates.
// The ICRS is a fixed, time independent frame and as such provides a unique reference
// frame without the need of specifying any epoch etc...
// The ICRS coordinate definitions match within 20 mas with the mean ones of the J2000.0
// equatorial system. Nevertheless, to obtain the highest accuracy, the slight
// coordinate correction between J2000 and ICRS is performed here via the
// so-called frame bias matrix.
// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
// which is available on http://aa.usno.navy.mil/publications/docs/Circular_179.pdf.
//
// The input parameter "frame" allows the user to specify the frame to which
// the components of r refer. Available options are :
//
//  frame = "equ" ==> Equatorial coordinates with right ascension (a) and declination (d),
//                    where the "sph" components of r correspond to theta=(pi/2)-d and phi=a.
//          "gal" ==> Galactic coordinates with longitude (l) and latitude (b).
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "ecl" ==> Geocentric ecliptic coordinates with longitude (l) and latitude (b),
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "hor" ==> Horizontal coordinates at the NcAstrolab location, where the "sph"
//                    components of r correspond to theta=zenith angle and phi=pi-azimuth.
//          "icr" ==> ICRS coordinates with longitude (l) and latitude (b),
//                    where the "sph" components of r correspond to theta=(pi/2)-b and phi=l.
//          "loc" ==> Local coordinates at the NcAstrolab location, where the "sph"
//                    components of r correspond to the usual theta and phi angles.
//
// In case the coordinates are the equatorial right ascension and declination (a,d),
// they can represent so-called "mean", "true" and reference "epoch" values.
// The distinction between these representations is the following :
//
// mean values  : (a,d) are only corrected for precession and not for nutation
// true values  : (a,d) are corrected for both precession and nutation
// epoch values : (a,d) are given w.r.t. specific (e.g. B1950 or J2000) reference equinox locations
//
// The input parameter "mode" allows the user to specifiy either "mean", "true" or "epoch"
// values for the input in case of equatorial (a,d) coordinates.
//
// mode = "M" --> Input coordinates are the mean values 
//        "T" --> Input coordinates are the true values 
//        "B" --> Besselian (B1950) reference epoch coordinates 
//        "J" --> Julian (J2000) reference epoch coordinates 
//
// The input parameters "jref" and "type" allow the user to store measurements or so-called "reference" signals.
// These reference signals may be used to check space-time event coincidences with the
// stored measurement(s) (e.g. coincidence of the measurement(s) with transient phenomena).
//
// jref = j --> Storage of a signal at the j-th position (j=1 is first)
//      < 0 --> Add a signal at the next available position
//
// type = 0 --> The entered data is a reference signal
//        1 --> The entered data is a measured signal
//
// Note : For backward compatibility jref=0 invokes the storage of a single measurement.
//        When invoked with jref=0 all other stored measurements will be lost.
//        However, the stored reference signals are not affected.
//        The user is advised not to use this obsolete jref=0 facility anymore. 
//
// Via the input argument "name" the user can give the stored signal also a name.
// If no name is provided, a name will be generated based on the type and the storage index,
// like for instance Meas8# or Ref5#.
//
// Notes :
// -------
// 1) In case ts=0 the current timestamp of the lab will be taken.
// 2) In case scrambling has been activated, the data will be scrambled accordingly.

Definition at line 1425 of file NcAstrolab.cxx.

SetSolarSystem()

Int_t NcAstrolab::SetSolarSystem ( TString name, NcTimestamp * ts, Int_t type = 0 )

protected

// Internal memberfunction to set c.q. update coordinates for solar system objects
// according to timestamp "ts".
// Due to the movement of the Earth around the Sun, the apparent coordinates
// of solar system objects change more rapidly than those of more distant objects.
// All locations are evaluated in geocentric ecliptic coordinates.   
// For further details see the U.S. Naval Observatory (USNO) circular 179 (2005),
// which is available on http://aa.usno.navy.mil/publications/docs/Circular_179.pdf.
//
// name : Name of the solar system object.
// ts   : Timestamp used to evaluate the position of the specified object.
// type : 0 --> The object data will be searched c.q. entered among the reference signals
//        1 --> The object data will be searched c.q. entered among the measured signals
//
// The return argument indicates whether a solar sytem object has been set/updated (1) or not (0).
//
// All geocentric name specifications as indicated in the docs of NcTimestamp::Almanac()
// are supported here.
//
// Note : In case ts=0 the current timestamp of this NcAstrolab instance will be taken.
//
// The default value is type=0 for backward compatibility.

Definition at line 1865 of file NcAstrolab.cxx.

SetSourceAttributes()

Int_t NcAstrolab::SetSourceAttributes	(	NcSignal *	s,
		Double_t	sigmapos,
		TString	u,
		Double_t	z = -999,
		Double_t	T90 = -999 )

// Set various attributes for an astrophysical object that is stored with the signal pointer "s".
// The signal pointer "s" can be obtained via the memberfunctions SetSignal() or GetSignal().
// 
// Input arguments :
// -----------------
// s        : Pointer to the signal with which the astrophysical object is stored
// sigmapos : The 1-sigma position angular uncertainty
// u        : The units in which sigmapos is specified (see below)
// z        : The redshift
// T90      : The T90 duration in seconds in case of a transient object
//
// u = "rad" : angular uncertainty provided in radians
//     "deg" : angular uncertainty provided in degrees
//     "dms" : angular uncertainty provided in dddmmss.sss
//     "hms" : angular uncertainty provided in hhmmss.sss
//     "hrs" : angular uncertainty provided in fractional hours
//
// In case a certain value is not known, a negative value should be provided.
//
// The return argument represents the number of attributes that were correctly set.
//
// The default values are z=-999 and T90=-999. 

Definition at line 2158 of file NcAstrolab.cxx.

SetTimeScramble()

void NcAstrolab::SetTimeScramble	(	Int_t	mode,
		Double_t	tmin,
		Double_t	tmax,
		TF1 *	frndm = 0 )

// Set parameters for time scrambling of the measurements.
// This scrambling facility is very useful for studying (accidental) background
// correlations and performing blind analyses.
//
// mode  : Mode for performing the time scrambling (see below)
// tmin  : Minimal value (in seconds) for time scrambling
// tmax  : Maximal value (in seconds) for time scrambling
// frndm : Randomising function to perform the scrambling
//
// Conventions for the mode parameter :
// ------------------------------------
// mode : 0 ==> No time scrambling is performed.
//        1 ==> Scrambling is only performed after having obtained the actual time difference.
//              So, the actual (stored) timestamps, retrieved coordinates c.q. angular differences
//              and the NcTimestamp::GetDifference() are not affected by the scrambling.
//              This implies that setting mode=0 will reproduce again the unscrambled values.
//              The provided time difference is randomly selected from the interval [tmin,tmax].
//              As such, this scrambling mode is very useful for scrambling entries in
//              specific time windows (see e.g. NvE, Astroparticle Physics 28 (2008) 540),
//              without modification of the event selection based on angular separation w.r.t. a source.
//              This time difference scrambling will only affect the outcome of the memberfunctions
//              GetDifference(), MatchRefSignal(), MatchSignals() and MatchBurstData() of this class NcAstrolab.
//              Note : Every time a time difference is requested, a new random value is produced.
//                     As such, scrambled values are not reproducible on subsequent invokations.
//        2 ==> Time scrambling is performed before storing the measurement.
//              A value is randomly selected from the interval [tmin,tmax] and added to the 
//              actual timestamp of the measurement.
//              The measurement will then be stored with the modified timestamp. 
//              As such, this scrambling is irreversible but will always provide reproducible results.
//              Note : In case the measurement is entered in NcAstrolab specific coordinates
//                     (i.e. local or horizontal position coordinates) then this mode=2 scrambling
//                     will also result in a corresponding scrambling of e.g. the right ascension.
//              Possible patterns in the distribution of sources on the sky will stay intact.
//        3 ==> Time scrambling is performed by using fake timestamps for the reference objects c.q. sources.
//              To create a fake timestamp, a value is randomly selected from the interval [tmin,tmax] and
//              added to the actual timestamp of the measurement.
//              This fake timestamp is then used to retrieve the local coordinates of the reference object,
//              whereas the local coordinates of the measurement are retrieved with the actual unmodified timestamp.
//              This implies that the time and local c.q. horizontal position coordinates of the measurement
//              will remain unchanged, but those of the reference object get modified.
//              These new local coordinates and time will then be used to obtain the and angular and time differences.
//              As such, this scrambling mode is very well suited to scramble both time and angular differences
//              w.r.t. sources, but keeping the local position (and consequently the reconstruction efficiency)
//              of the measurement unchanged.
//              So, the actual stored timestamps and coordinates are not affected by the scrambling.
//              This implies that setting mode=0 will reproduce again the unscrambled values.
//              This time scrambling will only affect the outcome of the memberfunctions
//              GetDifference(), MatchRefSignal(), MatchSignals() and MatchBurstData() of this class NcAstrolab.
//              Note : Every time a time difference is requested, a new random value is produced.
//                     As such, scrambled values are not reproducible on subsequent invokations.
//              Possible patterns in the distribution of sources on the sky will be washed out.
//       <0 ==> Similar as the corresponding mode>0, but the scrambling is only performed to obtain
//              the off-source background data in the memberfunction MatchBurstData().
//              So, the actual on-source recordings are not affected.  
//              Furthermore, for mode=-2 the scrambled timestamps are only used after retrieving the measurement
//              data from the storage, so the actual stored measurement data are not modified.   
//
// Notes :
// -------
// In case frndm=0 the scrambling will be performed via a uniform distribution.
//
// The default is frndm=0.
//
// In the NcAstrolab constructor the time scrambling is switched off
// by setting mode=0 explicitly.

Definition at line 5820 of file NcAstrolab.cxx.

ShiftPosition()

void NcAstrolab::ShiftPosition	(	Nc3Vector &	v,
		Double_t	angle )

// Shift the angular position for the vector "v" with the specified angular
// offset "angle" in degrees.
// The input argument "angle" determines an angular cone around the original
// pointing position of "v", on which a random new position will be chosen.
//
// Notes :
// -------
// 1) The vector components of "v" have to be initialised, since they define
//    the center around which the smearing will be performed.
//    However, in case the norm of "v" is not set, the norm will be automatically set to 1.
// 2) In case angular errors have been specified for the vector "v", the smeared vector
//    will obtain the same angular errors.

Definition at line 9088 of file NcAstrolab.cxx.

SkyMapPanel()

void NcAstrolab::SkyMapPanel ( )

virtual

// Main steering routine for the SkyMapPanel GUI.
// Invokation of this memberfunction will open an interactive GUI
// to provide a user friendly interface to this NcAstrolab instance
// to Enter, Remove, List and Display entries and their properties.

Definition at line 17593 of file NcAstrolab.cxx.

SmearPosition()

void NcAstrolab::SmearPosition	(	Nc3Vector &	v,
		Double_t	sigma )

// Smear the angular position for the vector "v" according to the specified
// pointing accuracy "sigma" in degrees.
// The input argument "sigma" determines the smearing in an angular cone (see below)
// around the actual pointing position of "v".
//
// sigma > 0 : Gaussian smearing in an angular cone with mean=0 and standard deviation "sigma" in degrees.
//       <=0 : Isotropic solid angle smearing in an angular cone of [0,abs(sigma)] in degrees.
// Notes :
// -------
// 1) The vector components of "v" have to be initialised, since they define
//    the center around which the smearing will be performed.
//    However, in case the norm of "v" is not set, the norm will be automatically set to 1.
// 2) In case angular errors have been specified for the vector "v", the smeared vector
//    will obtain the same angular errors.

Definition at line 9008 of file NcAstrolab.cxx.

TimestampPanel()

void NcAstrolab::TimestampPanel ( TGCompositeFrame * frame )

protectedvirtual

// Internal memberfunction to render the Timestamp specification GUI panel.

Definition at line 17887 of file NcAstrolab.cxx.

WriteBurstHistograms()

void NcAstrolab::WriteBurstHistograms

(

TString

filename

)

// Write all the generated transient burst histograms to a ROOT file with the specified filename.
//
// **********************************************************************************
// * This is a beta test version, so currently no backward compatibility guaranteed *
// **********************************************************************************

Definition at line 17562 of file NcAstrolab.cxx.

Member Data Documentation

fAlphaEM

Double_t NcAstrolab::fAlphaEM

protected

Definition at line 375 of file NcAstrolab.h.

fAmu

Double_t NcAstrolab::fAmu

protected

Definition at line 368 of file NcAstrolab.h.

fAu

Double_t NcAstrolab::fAu

protected

Definition at line 381 of file NcAstrolab.h.

fAxes

Double_t NcAstrolab::fAxes[6]

protected

Definition at line 253 of file NcAstrolab.h.

fB

TRotMatrix NcAstrolab::fB

protected

! The frame bias matrix for conversion of ICRS to J2000 coordinates

Definition at line 257 of file NcAstrolab.h.

fBias

Int_t NcAstrolab::fBias

protected

! Initialisation flag for fB values (0=uninitialised 1=initialised)

Definition at line 258 of file NcAstrolab.h.

fBoltz

Double_t NcAstrolab::fBoltz

protected

Definition at line 378 of file NcAstrolab.h.

fBurstHistos

TObjArray NcAstrolab::fBurstHistos

protected

Definition at line 410 of file NcAstrolab.h.

fBurstOffMatch

NcSample NcAstrolab::fBurstOffMatch

protected

Definition at line 416 of file NcAstrolab.h.

fBurstOffReco

NcSample NcAstrolab::fBurstOffReco

protected

Definition at line 415 of file NcAstrolab.h.

fBurstOnMatch

NcSample NcAstrolab::fBurstOnMatch

protected

Definition at line 412 of file NcAstrolab.h.

fBurstOnReco

NcSample NcAstrolab::fBurstOnReco

protected

Definition at line 411 of file NcAstrolab.h.

fBurstParameters

NcDevice* NcAstrolab::fBurstParameters

protected

Definition at line 409 of file NcAstrolab.h.

fBurstSignal

NcSample NcAstrolab::fBurstSignal

protected

Definition at line 414 of file NcAstrolab.h.

fBurstSigReco

NcSample NcAstrolab::fBurstSigReco

protected

Definition at line 413 of file NcAstrolab.h.

fCanvas

TCanvas* NcAstrolab::fCanvas

protected

! The canvas for the skymap

Definition at line 303 of file NcAstrolab.h.

fDataDir

Int_t NcAstrolab::fDataDir

protected

Definition at line 403 of file NcAstrolab.h.

fDataFrame

TString NcAstrolab::fDataFrame

protected

Definition at line 404 of file NcAstrolab.h.

fDataMode

TString NcAstrolab::fDataMode

protected

Definition at line 405 of file NcAstrolab.h.

fDataNames

NcObjMatrix NcAstrolab::fDataNames

protected

Definition at line 406 of file NcAstrolab.h.

fDscfunc

TF1* NcAstrolab::fDscfunc

protected

Definition at line 274 of file NcAstrolab.h.

fDscmax

Double_t NcAstrolab::fDscmax

protected

Definition at line 273 of file NcAstrolab.h.

fDscmin

Double_t NcAstrolab::fDscmin

protected

Definition at line 272 of file NcAstrolab.h.

fE

TRotMatrix NcAstrolab::fE

protected

! Matrix for conversion of equatorial to ecliptic coordinates

Definition at line 263 of file NcAstrolab.h.

fExperiment

TString NcAstrolab::fExperiment

protected

Definition at line 250 of file NcAstrolab.h.

fFermi

Double_t NcAstrolab::fFermi

protected

Definition at line 376 of file NcAstrolab.h.

fG

TRotMatrix NcAstrolab::fG

protected

! Matrix for conversion of equatorial to galactic coordinates

Definition at line 261 of file NcAstrolab.h.

fGal

Int_t NcAstrolab::fGal

protected

! Type indicator for fG values (0=uninitialised 1=B1950 2=J2000)

Definition at line 262 of file NcAstrolab.h.

fGammaW

Double_t NcAstrolab::fGammaW

protected

Definition at line 372 of file NcAstrolab.h.

fGammaZ

Double_t NcAstrolab::fGammaZ

protected

Definition at line 374 of file NcAstrolab.h.

fGn

Double_t NcAstrolab::fGn

protected

Definition at line 380 of file NcAstrolab.h.

fH

TRotMatrix NcAstrolab::fH

protected

! Matrix for conversion of equatorial to horizontal coordinates

Definition at line 264 of file NcAstrolab.h.

fHbar

Double_t NcAstrolab::fHbar

protected

Definition at line 391 of file NcAstrolab.h.

fHbarc

Double_t NcAstrolab::fHbarc

protected

Definition at line 392 of file NcAstrolab.h.

fHbarc2

Double_t NcAstrolab::fHbarc2

protected

Definition at line 393 of file NcAstrolab.h.

fHist

TH2* NcAstrolab::fHist[2]

protected

! Temp. histograms for the sky display

Definition at line 304 of file NcAstrolab.h.

fHubble

Double_t NcAstrolab::fHubble

protected

Definition at line 383 of file NcAstrolab.h.

fIndices

TArrayI* NcAstrolab::fIndices

protected

! Storage indices of the matching reference signals

Definition at line 266 of file NcAstrolab.h.

fL

TRotMatrix NcAstrolab::fL

protected

Definition at line 265 of file NcAstrolab.h.

fLabId

Int_t NcAstrolab::fLabId

protected

Definition at line 251 of file NcAstrolab.h.

fLabPos

NcPosition NcAstrolab::fLabPos

protected

Definition at line 249 of file NcAstrolab.h.

fMapCinfo

TString NcAstrolab::fMapCinfo

protected

! The GUI selected info category

Definition at line 334 of file NcAstrolab.h.

fMapDate

TString NcAstrolab::fMapDate

protected

! The GUI entered date

Definition at line 327 of file NcAstrolab.h.

fMapDateTime

TString NcAstrolab::fMapDateTime

protected

! The GUI entered datetime

Definition at line 330 of file NcAstrolab.h.

fMapDcoord

TString NcAstrolab::fMapDcoord

protected

! The GUI selected coordinate system for the Map/List

Definition at line 346 of file NcAstrolab.h.

fMapDmode

TString NcAstrolab::fMapDmode

protected

! The GUI selected coordinate system mode for the Map/List

Definition at line 348 of file NcAstrolab.h.

fMapDname

TString NcAstrolab::fMapDname

protected

! The GUI entered name pattern for entries to be shown in the Map/List

Definition at line 352 of file NcAstrolab.h.

fMapDoptions

Bool_t NcAstrolab::fMapDoptions[5]

protected

! The GUI Map/List options (histo, clr, ref, meas, refTS)

Definition at line 349 of file NcAstrolab.h.

fMapEa

Double_t NcAstrolab::fMapEa

protected

! The GUI entered a coordinate of an entry

Definition at line 338 of file NcAstrolab.h.

fMapEb

Double_t NcAstrolab::fMapEb

protected

! The GUI entered b coordinate of an entry

Definition at line 340 of file NcAstrolab.h.

fMapEcoord

TString NcAstrolab::fMapEcoord

protected

! The GUI entered coordinate system of the entry

Definition at line 343 of file NcAstrolab.h.

fMapEmode

TString NcAstrolab::fMapEmode

protected

! The GUI entered coordinate system mode of the entry

Definition at line 344 of file NcAstrolab.h.

fMapEname

TString NcAstrolab::fMapEname

protected

! The GUI entered name of the entry

Definition at line 345 of file NcAstrolab.h.

fMapEtype

Int_t NcAstrolab::fMapEtype

protected

! The GUI entered entry type

Definition at line 342 of file NcAstrolab.h.

fMapEua

TString NcAstrolab::fMapEua

protected

! The GUI entered angular units of a

Definition at line 339 of file NcAstrolab.h.

fMapEub

TString NcAstrolab::fMapEub

protected

! The GUI entered angular units of b

Definition at line 341 of file NcAstrolab.h.

fMapIname

TString NcAstrolab::fMapIname

protected

! The GUI selected entry name for the info

Definition at line 337 of file NcAstrolab.h.

fMapLabE

TGComboBox* NcAstrolab::fMapLabE

protected

! The GUI Lab experiment site selection box

Definition at line 319 of file NcAstrolab.h.

fMapLabExpName

TString NcAstrolab::fMapLabExpName

protected

! The GUI entered Lab experimental site

Definition at line 323 of file NcAstrolab.h.

fMapLabId

Int_t NcAstrolab::fMapLabId

protected

! The GUI entered Lab detector Id

Definition at line 324 of file NcAstrolab.h.

fMapLabLBI

TGNumberEntryField* NcAstrolab::fMapLabLBI[3]

protected

! The GUI number entries for the Lab location specification

Definition at line 317 of file NcAstrolab.h.

fMapLabLframe

TGNumberEntryField* NcAstrolab::fMapLabLframe[6]

protected

! The GUI number entries for the local frame specification

Definition at line 333 of file NcAstrolab.h.

fMapLabLocB

Double_t NcAstrolab::fMapLabLocB

protected

! The GUI entered Lab latitude

Definition at line 321 of file NcAstrolab.h.

fMapLabLocL

Double_t NcAstrolab::fMapLabLocL

protected

! The GUI entered Lab longitude

Definition at line 320 of file NcAstrolab.h.

fMapLabLocU

TString NcAstrolab::fMapLabLocU

protected

! The GUI entered Lab location angular units

Definition at line 322 of file NcAstrolab.h.

fMapLabTS

Bool_t NcAstrolab::fMapLabTS

protected

! The GUI selection to use the Lab timestamp for the List/Map

Definition at line 332 of file NcAstrolab.h.

fMapLabU

TGComboBox* NcAstrolab::fMapLabU

protected

! The GUI Lab location angular unit selection box

Definition at line 318 of file NcAstrolab.h.

fMapMarkColor

Int_t NcAstrolab::fMapMarkColor

protected

! The GUI selected marker color for the Map

Definition at line 359 of file NcAstrolab.h.

fMapMarkSize

Double_t NcAstrolab::fMapMarkSize

protected

! The GUI entered marker size for the Map

Definition at line 357 of file NcAstrolab.h.

fMapMarkStyle

Int_t NcAstrolab::fMapMarkStyle

protected

! The GUI selected marker style for the Map

Definition at line 358 of file NcAstrolab.h.

fMapMarkType

Int_t NcAstrolab::fMapMarkType

protected

! The GUI selected entry type to apply the marker attributes on

Definition at line 360 of file NcAstrolab.h.

fMapMerC

Double_t NcAstrolab::fMapMerC

protected

! The GUI entered central meridian location for the Map

Definition at line 355 of file NcAstrolab.h.

fMapMerMode

Int_t NcAstrolab::fMapMerMode

protected

! The GUI selected meridian orientation for the Map

Definition at line 354 of file NcAstrolab.h.

fMapMerUc

TString NcAstrolab::fMapMerUc

protected

! The GUI selected angular units for the central meridian location

Definition at line 356 of file NcAstrolab.h.

fMapNdigs

Int_t NcAstrolab::fMapNdigs

protected

! The GUI selected number of digits for the List output

Definition at line 351 of file NcAstrolab.h.

fMapNmax

Int_t NcAstrolab::fMapNmax

protected

! The GUI selected max. number of signals of each type to Map/List

Definition at line 350 of file NcAstrolab.h.

fMapProj

TString NcAstrolab::fMapProj

protected

! The GUI selected projection for the Map

Definition at line 347 of file NcAstrolab.h.

fMapSolar

Bool_t NcAstrolab::fMapSolar[10]

protected

! The GUI selection of solar system objects

Definition at line 353 of file NcAstrolab.h.

fMapTime

TString NcAstrolab::fMapTime

protected

! The GUI entered time

Definition at line 328 of file NcAstrolab.h.

fMapTimeType

TString NcAstrolab::fMapTimeType

protected

! The GUI entered time type

Definition at line 329 of file NcAstrolab.h.

fMapTinfo

Int_t NcAstrolab::fMapTinfo

protected

! The GUI selected mode for the timestamp info

Definition at line 335 of file NcAstrolab.h.

fMapTS

NcTimestamp NcAstrolab::fMapTS

protected

! The GUI entered timestamp to be used for the List/Map

Definition at line 331 of file NcAstrolab.h.

fMapTSdatetime

TGTextEntry* NcAstrolab::fMapTSdatetime

protected

! The GUI TS date/time specification

Definition at line 325 of file NcAstrolab.h.

fMapTStimetype

TGComboBox* NcAstrolab::fMapTStimetype

protected

! The GUI TS time type selection box

Definition at line 326 of file NcAstrolab.h.

fMapUinfo

TString NcAstrolab::fMapUinfo

protected

! The GUI selected angular units for the Lab info

Definition at line 336 of file NcAstrolab.h.

fMarkerColor

Int_t NcAstrolab::fMarkerColor[4]

protected

Definition at line 308 of file NcAstrolab.h.

fMarkers

TObjArray* NcAstrolab::fMarkers

protected

! Temp. array to hold the markers for the signal display

Definition at line 305 of file NcAstrolab.h.

fMarkerSize

Float_t NcAstrolab::fMarkerSize[4]

protected

Definition at line 306 of file NcAstrolab.h.

fMarkerStyle

Int_t NcAstrolab::fMarkerStyle[4]

protected

Definition at line 307 of file NcAstrolab.h.

fMaxDt

Double_t NcAstrolab::fMaxDt

protected

Definition at line 282 of file NcAstrolab.h.

fMe

Double_t NcAstrolab::fMe

protected

Definition at line 365 of file NcAstrolab.h.

fMeridian

Double_t NcAstrolab::fMeridian

protected

! Central meridian (in rad) for the sky display

Definition at line 301 of file NcAstrolab.h.

fMmu

Double_t NcAstrolab::fMmu

protected

Definition at line 366 of file NcAstrolab.h.

fMn

Double_t NcAstrolab::fMn

protected

Definition at line 370 of file NcAstrolab.h.

fMp

Double_t NcAstrolab::fMp

protected

Definition at line 369 of file NcAstrolab.h.

fMtau

Double_t NcAstrolab::fMtau

protected

Definition at line 367 of file NcAstrolab.h.

fMW

Double_t NcAstrolab::fMW

protected

Definition at line 371 of file NcAstrolab.h.

fMZ

Double_t NcAstrolab::fMZ

protected

Definition at line 373 of file NcAstrolab.h.

fN

TRotMatrix NcAstrolab::fN

protected

! Matrix for nutation correction

Definition at line 260 of file NcAstrolab.h.

fNen

ULong64_t NcAstrolab::fNen[2]

protected

Definition at line 256 of file NcAstrolab.h.

fNewton

Double_t NcAstrolab::fNewton

protected

Definition at line 379 of file NcAstrolab.h.

fNuAngle

TF1* NcAstrolab::fNuAngle

protected

Definition at line 396 of file NcAstrolab.h.

fOmegaB

Double_t NcAstrolab::fOmegaB

protected

Definition at line 387 of file NcAstrolab.h.

fOmegaC

Double_t NcAstrolab::fOmegaC

protected

Definition at line 388 of file NcAstrolab.h.

fOmegaL

Double_t NcAstrolab::fOmegaL

protected

Definition at line 386 of file NcAstrolab.h.

fOmegaM

Double_t NcAstrolab::fOmegaM

protected

Definition at line 384 of file NcAstrolab.h.

fOmegaR

Double_t NcAstrolab::fOmegaR

protected

Definition at line 385 of file NcAstrolab.h.

fP

TRotMatrix NcAstrolab::fP

protected

! Matrix for precession correction

Definition at line 259 of file NcAstrolab.h.

fPc

Double_t NcAstrolab::fPc

protected

Definition at line 382 of file NcAstrolab.h.

fPhiscfunc

TF1* NcAstrolab::fPhiscfunc

protected

Definition at line 280 of file NcAstrolab.h.

fPhiscmax

Double_t NcAstrolab::fPhiscmax

protected

Definition at line 279 of file NcAstrolab.h.

fPhiscmin

Double_t NcAstrolab::fPhiscmin

protected

Definition at line 278 of file NcAstrolab.h.

fPlanck

Double_t NcAstrolab::fPlanck

protected

Definition at line 377 of file NcAstrolab.h.

fProj

TString NcAstrolab::fProj

protected

! Projection which is currently in use

Definition at line 302 of file NcAstrolab.h.

fQe

Double_t NcAstrolab::fQe

protected

Definition at line 364 of file NcAstrolab.h.

fRan

NcRandom* NcAstrolab::fRan

protected

Definition at line 281 of file NcAstrolab.h.

fRefs

TObjArray* NcAstrolab::fRefs

protected

Definition at line 254 of file NcAstrolab.h.

fRscmode

Int_t NcAstrolab::fRscmode

protected

Definition at line 271 of file NcAstrolab.h.

fSigs

TObjArray* NcAstrolab::fSigs

protected

Definition at line 255 of file NcAstrolab.h.

fSkyMapPanel

TGMainFrame* NcAstrolab::fSkyMapPanel

protected

! The main frame for the SkyMapPanel GUI

Definition at line 316 of file NcAstrolab.h.

fSolUpdate

Int_t NcAstrolab::fSolUpdate

protected

Definition at line 296 of file NcAstrolab.h.

fSpeedC

Double_t NcAstrolab::fSpeedC

protected

Definition at line 363 of file NcAstrolab.h.

fThetascfunc

TF1* NcAstrolab::fThetascfunc

protected

Definition at line 277 of file NcAstrolab.h.

fThetascmax

Double_t NcAstrolab::fThetascmax

protected

Definition at line 276 of file NcAstrolab.h.

fThetascmin

Double_t NcAstrolab::fThetascmin

protected

Definition at line 275 of file NcAstrolab.h.

fToffset

Double_t NcAstrolab::fToffset

protected

Definition at line 252 of file NcAstrolab.h.

fTscfunc

TF1* NcAstrolab::fTscfunc

protected

Definition at line 270 of file NcAstrolab.h.

fTscmax

Double_t NcAstrolab::fTscmax

protected

Definition at line 269 of file NcAstrolab.h.

fTscmin

Double_t NcAstrolab::fTscmin

protected

Definition at line 268 of file NcAstrolab.h.

fTscmode

Int_t NcAstrolab::fTscmode

protected

Definition at line 267 of file NcAstrolab.h.

fUsMeridian

Int_t NcAstrolab::fUsMeridian

protected

Definition at line 300 of file NcAstrolab.h.

---

The documentation for this class was generated from the following files:

• ncfspack/source/NcAstrolab.h
• ncfspack/source/NcAstrolab.cxx