funcnts - En ligne dans le Cloud

PROGRAMME:

Nom

funcnts - compte les photons dans des régions spécifiées, avec soustraction bkgd

SYNOPSIS

fonctions [commutateurs] [région_source] [fichier_bkgd] [région_bkgd⎪valeur_bkgd]

OPTIONS

-e "source_exposition[;bkgd_exposition]"
# source (bkgd) image d'exposition FITS utilisant des fichiers correspondants
-w "source_exposition[;bkgd_exposition]"
# source (bkgd) image d'exposition FITS utilisant la transformation WCS
-t "source_timecorr[;bkgd_timecorr]"
# source (bkgd) valeur de correction de l'heure ou nom du paramètre d'en-tête
-g # sortie en utilisant le bon format g
-G # sortie au format %.14g (précision maximale)
-i "[column;]int1;int2..." # intervalles basés sur des colonnes
-m # correspond aux régions source et bkgd individuelles
-p # sortie en pixels, même si wcs est présent
-r # sortie des rayons intérieurs/extérieurs (et angles) pour les anneaux (et les pandas)
-s # afficher les valeurs additionnées
-v "scol[;bcol]" # colonnes de valeurs src et bkgd pour les tables
-T # sortie au format starbase/rdb
-z # régions de sortie avec une zone nulle

DESCRIPTION

fonctions compte les photons dans les régions source spécifiées et rapporte les résultats pour chaque
Région. Les régions sont spécifiées à l'aide du mécanisme de filtrage des régions spatiales. Les photons sont
également compté dans les régions bkgd spécifiées appliquées au même fichier de données ou à un autre
fichier de données. (Alternativement, une valeur de fond constante en nombres/pixel**2 peut être
spécifié.) Les régions bkgd sont soit jumelées une à une avec les régions source, soit regroupées
et normalisé par zone, puis soustrait des dénombrements de source dans chaque région.
Les résultats affichés incluent les nombres soustraits bkgd dans chaque région, ainsi que l'erreur
sur les comptages, la superficie de chaque région et la luminosité de la surface (cnts/area**2)
calculé pour chaque région.

Le premier argument du programme spécifie l'image d'entrée FITS, le tableau ou le fichier d'événement brut
procéder. Si "stdin" est spécifié, les données sont lues à partir de l'entrée standard. Utiliser Funtools
Bracket Notation pour spécifier les extensions FITS, les sections d'image et les filtres.

Le deuxième argument facultatif est le descripteur de région source. Si aucune région n'est spécifiée,
tout le champ est utilisé.

Les arguments d'arrière-plan peuvent prendre l'une des deux formes, selon qu'un
le fichier d'arrière-plan est spécifié. Si le fichier source doit également être utilisé comme arrière-plan, le
le troisième argument peut être soit la région d'arrière-plan, soit une valeur constante indiquant
cnts/pixel d'arrière-plan. Alternativement, le troisième argument peut être un fichier de données d'arrière-plan,
auquel cas le quatrième argument est la région d'arrière-plan. Si aucun troisième argument n'est
spécifié, une valeur constante de 0 est utilisée (c'est-à-dire aucun arrière-plan).

En résumé, les arguments de commande suivants sont valides :

[sh] funcnts sfile # compte dans le fichier source
[sh] funcnts sfile sregion # compte dans la région source
[sh] funcnts sfile sregion bregion # bkgd reg. provient du fichier source
[sh] funcnts sfile sregion bvalue # bkgd reg. est constant
[sh] funcnts sfile sregion bfile bregion # bkgd reg. provient d'un fichier séparé

NB : contrairement aux autres programmes Funtools, les régions source et d'arrière-plan sont spécifiées comme
arguments séparés sur la ligne de commande, plutôt que d'être placés entre crochets en tant que partie
des noms de fichiers source et d'arrière-plan. C'est parce que les régions dans les fonctions ne sont pas simplement
utilisés comme filtres de données, mais sont également utilisés pour calculer les zones, l'exposition, etc. Si vous mettez le
région source à l'intérieur des crochets (c'est-à-dire l'utiliser simplement comme un filtre) plutôt que de spécifier
comme argument deux, le programme ne comptera toujours que les photons qui passent le filtre de région.
Cependant, le calcul de l'aire sera effectué sur l'ensemble du champ, puisque champ() est
région source par défaut. C'est rarement le comportement souhaité. En revanche, avec FITS
tables binaires, il est souvent utile de mettre un filtre de colonne entre parenthèses de nom de fichier, afin que
seuls les événements correspondant au filtre de colonne sont comptés à l'intérieur de la région.

Par exemple, pour extraire les comptes dans un rayon de 22 pixels à partir du centre du
FITS table binaire snr.ev et soustraire l'arrière-plan déterminé à partir de la même image dans
un anneau de rayons 50-100 pixels :

[sh] funcnts snr.ev "cercle (502,512,22)" "annulus (502,512,50,100)"
# la source
# fichier de données : snr.ev
# degrés/pixel : 0.00222222
# Contexte
# fichier de données : snr.ev
# unités de colonne
# zone : arcsec**2
# surf_bri : cnts/arcsec**2
# surf_err : cnts/arcsec**2

# résultats soustraits en arrière-plan
reg net_counts erreur arrière-plan zone de berror surf_bri surf_err
---- ------------ --------- ------------ --------- ---- ----- --------- ---------
1 3826.403 66.465 555.597 5.972 96831.98 0.040 0.001

# les composants source et d'arrière-plan suivants ont été utilisés :
région(s) source(s)
----------------
cercle (502,512,22)

reg compte les pixels
---- ------------ ---------
+1 (4382.000)1513

région(s) d'arrière-plan
--------------------
anneau (502,512,50,100)

reg compte les pixels
---- ------------ ---------
tous 8656.000 23572

Les unités de surface pour les colonnes de sortie intitulées « surface », « surf_bri » (luminosité de la surface) et
"surf_err" sera donné soit en secondes d'arc (si les informations WCS appropriées sont dans le
en-tête(s) du fichier de données) ou en pixels. Si le fichier de données contient des informations WCS, mais que vous ne voulez pas d'arc-
deuxièmes unités, utilisez le -p passer pour forcer la sortie en pixels. De plus, les régions ayant une aire nulle
ne sont normalement pas inclus dans le tableau principal (soustrait en arrière-plan), mais sont inclus
dans les tables source secondaire et bkgd. Si vous souhaitez que ces régions soient incluses dans le
table primaire, utilisez le -z interrupteur.

Notez qu'une simple commande sed extraira les résultats soustraits en arrière-plan pour plus de
une analyse:

[sh] cat funcnts.sed
1,/---- .*/j
/^$/,$d

[sh] sed -f funcnts.sed funcnts.out
1 3826.403 66.465 555.597 5.972 96831.98 0.040 0.001

Si des fichiers source et d'arrière-plan séparés sont spécifiés, fonctions tentera de normaliser
la zone d'arrière-plan de sorte que la taille du pixel d'arrière-plan soit la même que le pixel source
Taille. Cette normalisation ne peut avoir lieu que si les informations WCS appropriées sont
contenus dans les deux fichiers (par exemple, valeurs degrés/pixels dans CDELT). Si l'un des fichiers ne
contiennent les informations de taille requises, la normalisation n'est pas effectuée. Dans ce cas,
il est de la responsabilité de l'utilisateur de s'assurer que les tailles de pixels sont les mêmes pour les deux
fichiers.

Normalement, si plusieurs régions d'arrière-plan sont spécifiées, fonctions les combinera tous
dans une seule région et utiliser cette région de fond pour produire le fond soustrait
résultats pour chaque région source. Les -m (faire correspondre plusieurs arrière-plans) le commutateur indique fonctions
pour faire une correspondance un à un entre l'arrière-plan et les régions source, au lieu de
en utilisant une seule région d'arrière-plan combinée. Par exemple, le cas par défaut est de combiner 2
régions d'arrière-plan dans une seule région, puis appliquez cette région à chacune des sources
Régions:

[sh] funcnts snr.ev "annulus(502,512,0,22,n=2)" "annulus(502,512,50,100,n=2)"
# la source
# fichier de données : snr.ev
# degrés/pixel : 0.00222222
# Contexte
# fichier de données : snr.ev
# unités de colonne
# zone : arcsec**2
# surf_bri : cnts/arcsec**2
# surf_err : cnts/arcsec**2

# résultats soustraits en arrière-plan
reg net_counts erreur arrière-plan zone de berror surf_bri surf_err
---- ------------ --------- ------------ --------- ---- ----- --------- ---------
1 3101.029 56.922 136.971 1.472 23872.00 0.130 0.002
2 725.375 34.121 418.625 4.500 72959.99 0.010 0.000

# les composants source et d'arrière-plan suivants ont été utilisés :
région(s) source(s)
----------------
anneau (502,512,0,22,n=2)

reg compte les pixels
---- ------------ ---------
+1 (3238.000)373
+2 (1144.000)1140

région(s) d'arrière-plan
--------------------
anneau (502,512,50,100,n=2)

reg compte les pixels
---- ------------ ---------
tous 8656.000 23572

Notez que la règle de base du filtre de région "chaque photon est compté une fois et aucun photon n'est
compté plus d'une fois" s'applique toujours lors de l'utilisation de The -m pour faire correspondre les régions d'arrière-plan. Cette
est, si deux régions d'arrière-plan se chevauchent, les pixels qui se chevauchent seront comptés dans un seul
d'eux. Dans le pire des cas, si deux régions d'arrière-plan sont la même région, le
le premier obtiendra tous les comptes et la superficie et le second n'en obtiendra aucun.

Le -m cause du changement fonctions d'utiliser chacune des deux régions d'arrière-plan indépendamment
avec chacune des deux régions sources :

[sh] funcnts -m snr.ev "annulus(502,512,0,22,n=2)" "ann(502,512,50,100,n=2)"
# la source
# fichier de données : snr.ev
# degrés/pixel : 0.00222222
# Contexte
# fichier de données : snr.ev
# unités de colonne
# zone : arcsec**2
# surf_bri : cnts/arcsec**2
# surf_err : cnts/arcsec**2

# résultats soustraits en arrière-plan
reg net_counts erreur arrière-plan zone de berror surf_bri surf_err
---- ------------ --------- ------------ --------- ---- ----- --------- ---------
1 3087.015 56.954 150.985 2.395 23872.00 0.129 0.002
2 755.959 34.295 388.041 5.672 72959.99 0.010 0.000

# les composants source et d'arrière-plan suivants ont été utilisés :
région(s) source(s)
----------------
anneau (502,512,0,22,n=2)

reg compte les pixels
---- ------------ ---------
+1 (3238.000)373
+2 (1144.000)1140

région(s) d'arrière-plan
--------------------
an(502,512,50,100,n=2)

reg compte les pixels
---- ------------ ---------
+1 (3975.000)9820
+2 (4681.000)13752

Notez que la plupart des quantités à virgule flottante sont affichées au format "f". Vous pouvez changer
ceci au format "g" en utilisant le -g changer. Cela peut être utile lorsque les comptes dans chaque pixel
est très petit ou très grand. Si vous voulez une précision maximale et ne vous souciez pas de la
les colonnes s'alignent bien, utilisez -G, qui renvoie toutes les valeurs flottantes sous la forme %.14g.

Lors du comptage de photons en utilisant les formes annulus et panda (tarte et annuli), il est souvent
utile d'avoir accès aux rayons (et angles de panda) pour chaque région distincte. Les -r
Le commutateur ajoutera des colonnes de rayon et d'angle à la table de sortie :

[sh] funcnts -r snr.ev "annulus(502,512,0,22,n=2)" "ann(502,512,50,100,n=2)"
# la source
# fichier de données : snr.ev
# degrés/pixel : 0.00222222
# Contexte
# fichier de données : snr.ev
# unités de colonne
# zone : arcsec**2
# surf_bri : cnts/arcsec**2
# surf_err : cnts/arcsec**2
# rayons : secondes d'arc
# angles : degrés

# résultats soustraits en arrière-plan
reg net_counts erreur arrière-plan berror area surf_bri surf_err radius1 radius2 angle1 angle2
---- ------------ --------- ------------ --------- ---- ----- --------- --------- --------- --------- --------- ---------
1 3101.029 56.922 136.971 1.472 23872.00 0.130 0.002 0.00 88.00 NA NA
2 725.375 34.121 418.625 4.500 72959.99 0.010 0.000 88.00 176.00 NA NA

# les composants source et d'arrière-plan suivants ont été utilisés :
région(s) source(s)
----------------
anneau (502,512,0,22,n=2)

reg compte les pixels
---- ------------ ---------
+1 (3238.000)373
+2 (1144.000)1140

région(s) d'arrière-plan
--------------------
an(502,512,50,100,n=2)

reg compte les pixels
---- ------------ ---------
tous 8656.000 23572

Les rayons sont donnés en unités de pixels ou en secondes d'arc (selon la présence d'informations WCS),
tandis que les valeurs d'angle (lorsqu'elles sont présentes) sont en degrés. Ces colonnes peuvent être utilisées pour tracer
profils radiaux. Par exemple, le script fonctions.plot dans la distribution funtools)
tracer un profil radial en utilisant gnuplot (version 3.7 ou supérieure). Une version simplifiée de ce
le script est présenté ci-dessous :

#!/ Bin / sh

if [ x"$1" = xgnuplot ]; alors
if [ x`which gnuplot 2>/dev/null` = x ]; alors
echo "ERREUR : gnuplot non disponible"
sortie 1
fi
ah '
COMMENCER{HEADER=1; DONNÉES=0 ; FICHIERS="" ; XLABEL="inconnu" ; YLABEL="inconnu"}
EN-TÊTE==1{
if( $1 == "#" && $2 == "données" && $3 == "fichier :" ){
if( FICHIERS != "" ) FICHIERS = FICHIERS ","
FICHIERS = FICHIERS $4
}
else if( $1 == "#" && $2 == "radii:" ){
XLABEL = 3 $
}
else if( $1 == "#" && $2 == "surf_bri:" ){
YLABEL = 3 $
}
else if( $1 == "----" ){
printf "définir nokey ; définir le titre \"funcnts(%s)\"\n", FICHIERS
printf "définir xlabel \" rayon(%s)\"\n", XLABEL
printf "définir ylabel \"surf_bri(%s)\"\n", YLABEL
imprimez "plot \"-\" en utilisant 3:4:6:7:8 avec boxerrorbars"
EN-TÊTE = 0
DONNÉES = 1
next
}
}
DONNÉES==1{
si( NF == 12 ){
imprimer 9 $, 10 $, (9 $+10 $)/2, 7 $, 8 $, 7 $ à 8 $, 7 $+8 $, 10 $ à 9 $
}
sinon {
sortie
}
}
' ⎪ gnuplot -persist - 1>/dev/null 2>&1

elif [ x"$1" = xds9 ]; alors
ah '
COMMENCER{HEADER=1; DONNÉES=0 ; XLABEL="inconnu" ; YLABEL="inconnu"}
EN-TÊTE==1{
if( $1 == "#" && $2 == "données" && $3 == "fichier :" ){
if( FICHIERS != "" ) FICHIERS = FICHIERS ","
FICHIERS = FICHIERS $4
}
else if( $1 == "#" && $2 == "radii:" ){
XLABEL = 3 $
}
else if( $1 == "#" && $2 == "surf_bri:" ){
YLABEL = 3 $
}
else if( $1 == "----" ){
printf "funcnts(%s) radius(%s) surf_bri(%s) 3\n", FILES, XLABEL, YLABEL
EN-TÊTE = 0
DONNÉES = 1
next
}
}
DONNÉES==1{
si( NF == 12 ){
imprimer 9 $, 7 $, 8 $
}
sinon {
sortie
}
}
'
d'autre
echo "funcnts -r ... ⎪ funcnts.plot [ds9⎪gnuplot]"
sortie 1
fi

Ainsi, pour courir fonctions et tracez les résultats à l'aide de gnuplot (version 3.7 ou supérieure), utilisez :

funcnts -r snr.ev "annulus(502,512,0,50,n=5)" ... ⎪ funcnts.plot gnuplot

La -s (somme) causes de commutation fonctions pour produire une table supplémentaire de somme (intégrée)
valeurs soustraites en arrière-plan, ainsi que le tableau par défaut des valeurs individuelles :

[sh] funcnts -s snr.ev "annulus(502,512,0,50,n=5)" "annulus(502,512,50,100)"
# la source
# fichier de données : snr.ev
# degrés/pixel : 0.00222222
# Contexte
# fichier de données : snr.ev
# unités de colonne
# zone : arcsec**2
# surf_bri : cnts/arcsec**2
# surf_err : cnts/arcsec**2

# résultats sommés en arrière-plan
jusqu'à net_counts erreur de fond zone de berror surf_bri surf_err
---- ------------ --------- ------------ --------- ---- ----- --------- ---------
1 2880.999 54.722 112.001 1.204 19520.00 0.148 0.003
2 3776.817 65.254 457.183 4.914 79679.98 0.047 0.001
3 4025.492 71.972 1031.508 11.087 179775.96 0.022 0.000
4 4185.149 80.109 1840.851 19.786 320831.94 0.013 0.000
5 4415.540 90.790 2873.460 30.885 500799.90 0.009 0.000

# résultats soustraits en arrière-plan
reg compte erreur arrière-plan zone d'erreur surf_bri surf_err
---- ------------ --------- ------------ --------- ---- ----- --------- ---------
1 2880.999 54.722 112.001 1.204 19520.00 0.148 0.003
2 895.818 35.423 345.182 3.710 60159.99 0.015 0.001
3 248.675 29.345 574.325 6.173 100095.98 0.002 0.000
4 159.657 32.321 809.343 8.699 141055.97 0.001 0.000
5 230.390 37.231 1032.610 11.099 179967.96 0.001 0.000

# les composants source et d'arrière-plan suivants ont été utilisés :
région(s) source(s)
----------------
anneau (502,512,0,50,n=5)

reg compte les pixels sumcnts sumpix
---- ------------ --------- ------------ ---------
1 2993.000 305 2993.000 305
2 1241.000 940 4234.000 1245
3 823.000 1564 5057.000 2809
4 969.000 2204 6026.000 5013
5 1263.000 2812 7289.000 7825

région(s) d'arrière-plan
--------------------
anneau (502,512,50,100)

reg compte les pixels
---- ------------ ---------
tous 8656.000 23572

La -t ainsi que -e les commutateurs peuvent être utilisés pour appliquer des corrections de synchronisation et d'exposition, respectivement,
aux données. Veuillez noter que ces corrections sont destinées à être utilisées qualitativement, car
l'application de facteurs de correction plus précis est un effort complexe et dépendant de la mission.
L'algorithme d'application de ces corrections simples est le suivant :

C = nombres bruts dans la région source
Ac= Zone de la région source
Tc = temps d'exposition pour les données sources
Ec= Exposition moyenne dans la région source, d'après la carte d'exposition

B = nombres bruts dans la région d'arrière-plan
Ab = zone de la région d'arrière-plan
Tb = temps (d'exposition) pour les données de fond
Eb= Exposition moyenne dans la région d'arrière-plan, à partir de la carte d'exposition

Ensuite, le nombre net dans la région source est

Net = C - B * (Ac*Tc*Ec)/(Ab*Tb*Eb)

avec la propagation standard des erreurs pour l'Erreur sur le Net. Le taux net serait alors

Taux net = Net/(Ac*Tc*Ec)

L'exposition moyenne dans chaque région est calculée en additionnant les valeurs de pixels dans le
carte d'exposition pour la région donnée, puis en divisant par le nombre de pixels dans cette
Région. Les cartes d'exposition sont souvent générées à un facteur de bloc > 1 (par exemple, le bloc 4 signifie que
chaque pixel d'exposition contient 4x4 pixels en pleine résolution) et fonctions traitera de la
blocage automatique. En utilisant le -e commutateur, vous pouvez fournir à la fois la source et l'arrière-plan
fichiers d'exposition (séparés par ";"), si vous avez des fichiers de données source et d'arrière-plan séparés.
Si vous ne fournissez pas de fichier d'exposition d'arrière-plan pour aller avec des données d'arrière-plan distinctes
fichier, fonctions suppose que l'exposition a déjà été appliquée au fichier de données d'arrière-plan.
De plus, il suppose que l'erreur sur les pixels dans le fichier de données d'arrière-plan est nulle.

NB: le -e le commutateur suppose que la carte d'exposition recouvre le fichier image exactement, sauf
pour le facteur de bloc. Chaque pixel de l'image est mis à l'échelle par le facteur de bloc pour accéder au
pixel correspondant dans la carte d'exposition. Si votre carte d'exposition ne s'aligne pas exactement
avec l'image, do ne sauraient utilisé le -e correction d'exposition. Dans ce cas, il est encore possible
pour effectuer une correction d'exposition if l'image et la carte d'exposition ont toutes deux un WCS valide
informations : utilisez le -w basculer pour que la transformation du pixel de l'image en exposition
pixel utilise les informations WCS. C'est-à-dire que chaque pixel de la région de l'image sera
transformé d'abord des coordonnées de l'image en coordonnées du ciel, puis des coordonnées du ciel en
coordonnées d'exposition. Veuillez noter qu'en utilisant -w peut augmenter le temps de traitement
considérablement la correction d'exposition.

Une correction temporelle peut être appliquée à la fois aux données source et aux données d'arrière-plan en utilisant le -t interrupteur.
La valeur de la correction peut être soit une constante numérique, soit le nom d'un en-tête
paramètre dans le fichier source (ou d'arrière-plan) :

[sh] funcnts -t 23.4 ... # nombre pour la source
[sh] funcnts -t "LIVETIME;23.4" ... # param pour la source, numérique pour bkgd

Lorsqu'une correction de temps est spécifiée, elle est également appliquée aux comptes nets (voir
ci-dessus), de sorte que les unités de luminosité de surface deviennent cnts/area**2/sec.

La -i (intervalle) le commutateur est utilisé pour exécuter fonctions sur plusieurs intervalles basés sur des colonnes avec
un seul passage à travers les données. C'est équivalent à courir fonctions plusieurs fois
avec un filtre de colonne différent ajouté à la source et aux données d'arrière-plan à chaque fois. Pour chaque
intervalle, le plein fonctions la sortie est générée, avec un caractère de saut de ligne (^L) inséré
entre chaque course. De plus, la sortie pour chaque intervalle contiendra l'intervalle
spécification dans son en-tête. Les intervalles sont très utiles pour générer la dureté aux rayons X
ratios efficacement. Bien sûr, ils ne sont pris en charge que lorsque les données d'entrée sont contenues
dans une table.

Deux formats sont pris en charge pour la spécification des intervalles. Le format le plus général est semi-
liste délimitée par des deux-points de filtres à utiliser comme intervalles :

funcnts -i "pha=1:5;pha=6:10;pha=11:15" snr.ev "circle(502,512,22)" ...

Conceptuellement, cela équivaudra à exécuter fonctions trois fois:

funcnts snr.ev'[pha=1:5]' "cercle (502,512,22)"
funcnts snr.ev'[pha=6:10]' "cercle (502,512,22)"
funcnts snr.ev'[pha=11:15]' "cercle (502,512,22)"

Cependant, en utilisant le -i commutateur ne nécessitera qu'un seul passage à travers les données.

Notez que des filtres complexes peuvent être utilisés pour spécifier des intervalles :

funcnts -i "pha=1:5&&pi=4;pha=6:10&&pi=5;pha=11:15&&pi=6" snr.ev ...

Le programme exécute simplement les données à travers chaque filtre à tour de rôle et génère trois fonctions
sorties, séparées par le caractère de saut de ligne.

En fait, bien que l'intention soit de prendre en charge les intervalles pour les rapports de dureté, les valeurs spécifiées
les filtres ne doivent pas du tout être des intervalles. Un filtre "à intervalle" ne doit pas non plus être
liés à un autre. Par exemple:

funcnts -i "pha=1:5;pi=6:10;energy=11:15" snr.ev "circle(502,512,22)" ...

équivaut à courir fonctions trois fois avec des spécifications de filtre indépendantes.

Un deuxième format d'intervalle est pris en charge pour le cas simple dans lequel une seule colonne est utilisée
pour spécifier plusieurs intervalles homogènes pour cette colonne. Dans ce format, un nom de colonne
est spécifié en premier, suivi des intervalles :

funcnts -i "pha;1:5;6:10;11:15" snr.ev "circle (502,512,22)" ...

Ceci est équivalent au premier exemple, mais nécessite moins de frappe. Les fonctions Danse
ajoutera simplement " pha=" avant chacun des intervalles spécifiés. (Notez que ce format
ne contient pas le caractère "=" dans l'argument de colonne.)

D'ordinaire, quand fonctions est exécuté sur une table binaire FITS (ou une table d'événements bruts), un
le compte intégral est accumulé pour chaque ligne (événement) contenue dans une région donnée. Les -v
"scol[;bcol]" (colonne de valeur) accumulera des comptes en utilisant la valeur de la
colonne spécifiée pour l'événement donné. Si une seule colonne est spécifiée, elle est utilisée pour
les régions source et d'arrière-plan. Deux colonnes distinctes, séparées par un point-virgule,
peut être spécifié pour la source et l'arrière-plan. Le jeton spécial '$none' peut être utilisé pour
spécifier qu'une colonne de valeur doit être utilisée pour l'un mais pas pour l'autre. Par exemple,
'pha;$none' utilisera la colonne pha pour la source mais utilisera des comptes intégraux pour le
background, tandis que '$none;pha' fera l'inverse. Si la colonne de valeur est de type
logique, alors la valeur utilisée sera 1 pour T et 0 pour F. Des colonnes de valeurs sont utilisées, pour
exemple, pour intégrer des probabilités au lieu de comptes intégraux.

Si la -T (table rdb) est utilisé, la sortie sera conforme à la base de données starbase/rdb
format : des tabulations seront insérées entre les colonnes plutôt que des espaces et le saut de ligne sera
inséré entre les tables.

Enfin, notez que fonctions est un programme d'image, même s'il peut être exécuté directement sur FITS
tableaux binaires. Cela signifie qu'un filtrage d'image est appliqué aux lignes afin de garantir
que les mêmes résultats sont obtenus qu'il s'agisse d'une table ou de l'équivalent
l'image est utilisée. Pour cette raison, cependant, le nombre de comptes trouvés en utilisant fonctions vous
diffèrent du nombre d'événements trouvés à l'aide de programmes de filtrage de lignes tels que fonds or
table amusante Pour plus d'informations sur ces différences, voir la discussion sur la région
Limites.

Utiliser des fonctions en ligne à l'aide des services onworks.net