The HIFI User's Manual

HIFI data are uniquely labeled by an obsid and, for now, are stored in HIFI ICC Versant Databases. Check the ICC Database contents listing to find which database an obsid is associated with, as well as for information about the observation. You will also find there the schema version of the database: you can only access databases that are at the same schema version as your HCSS software.

Databases are named according to the data's test enviroment, for example IST data is held in databases labeled ist_fm_x_prop (x is an integer), while simulator data is stored in ds1. You can change database within HIPE and JIDE but you can also set your preferred default in the property file (myconfig for Linux) as follows:

hcss.binstruct.mib.source = pal
hcss.binstruct.factory = herschel.hifi.share.binstruct.HifiBinstructFactory
hcss.binstruct.services = herschel.binstruct.mib.MibPalServices

You define the database to be used with var.database.devel, for example:

var.database.devel = ilt_fm_5_prop${var.database.server} 0 READ

The hifi-cal database contains calibration information needed, for example, to process data through the pipeline. There are two ways of getting this information into a Herschel DP session. One is to use the Versant databases at the HIFI ICC, to do this you should add this line to your config file:

hcss.binstruct.mib.pal.database = hifi-cal_dev@iccdb.sron.rug.nl 0 READ

The hifi-cal_dev and ilt_fm_5_prop_dev databases are always at the latest schema version.

The other is to install the hifi-cal locally on your machine from a copy of that at the ICC. First, download the local store copy of the hifi-cal. and unpack this in your .hcss directory. Second, change a Binstruct property so that it will look for a local copy of the database:

#hcss.binstruct.factory = herschel.hifi.share.binstruct.HifiBinstructFactory
hcss.binstruct.factory = herschel.binstruct.DefaultBinstructFactory
hcss.binstruct.mib.pal.poolname = hifi-cal

This will now point to a local pool to get the MIB (Mission Information Base) needed for the HifiTimelineProduct.

The MIB data are needed to define and interpret uplink commands and downlink housekeeping. The housekeeping is interpreted using the binstruct module and are associated with a MIB via the TmVersion tables, which map a MIB to a period in time. We have different tm-version tables for each test environment (e.g., "ilt-qm", "ilt-fm", "ilt-par", "ist-fm"). You can set the tmversion with the following binstruct property:

hcss.binstruct.mib.pal.tm_version_map = ilt-fm

There is a dedicated tmversion table for the TB/TV test environment, it is required because the TB/TV data overlaps (in time) with the SOVT1 data but the applied MIB data differ. It contains references for the hifi_mib_2140 (before 4 Nov, 2008) and the hifi_mib_2143 (after 4 Nov, 2008). The MIB 2143 will also be applied for SPG processing during SOVT2, and contains downlink related updates. It can be downloaded from http://www.sron.rug.nl/hifi_icc/protected/userinfo/download/hifi-cal-lstore-19-Dec.tgz. If you are running Windows try the http://www.sron.rug.nl/hifi_icc/protected/userinfo/download/hifi-cal-lstore-19-Dec.tar version to avoid zipping issues.

This lstore contains the TB/TV tm-version table, which you can activate by setting:

hcss.binstruct.mib.pal.tm_version_map = ist-tbtv

in addition to your regular binstruct setup.

For SOVT1 science data the ist-fm tmVersion table is still used. If you are interested in the satellite HK for SOVT1 data, you need to use the merged MIB available in the above hifi-cal pool with the tmVersion table ist-all. In the near future, the merged MIB for analysis of SOVT2 satellite HK wil be added to the "ist-all" tm version table. Applying merged MIBS for your analysis requires the following binstruct property be set:

hcss.binstruct.services=herschel.binstruct.hpsdb.HpsdbPalServices. 

The automatic use of the different tmVersion tables to associate HouseKeeping data via its mission configuration name will be available when SPR 2111 is implemented.

Running into the java heap space error can be a common affliction when using HCSS software, especially when running the pipeline. Here are some things to help:

Swap Store Properties:  It is possible to use the hard disk as swap space to preserve the memory available in Jide/Hipe. The following properties are defined to preserve computer memory. This becomes especially useful when pipeline processing long observations on a laptop, or on a pc with a 32 bit Operative System (TBC) and with average or limited memories capacities. However, any Task that uses or changes any HifiProduct (e.g., HifiTimelineProduct) will benefit from the use of swap space.

The following properties can be defined (in the myconfig file or using the "Hifi Product" tab in propgen) to set or to configure the Swap mechanism.

from herschel.hifi.pipeline.product import SwapUtil
SwapUtil.delete()

HIFI spectra can be stored in various formats, and there are various ways to access them.

HIFI spectra can be stored in various ways. While users may import data from the Versant database (section "Accessing Versant Database"), they usually store their products on a local disk in one of the following ways.

HIFI spectra can be visualised in several ways, at various levels of sophistication and user-friendliness. Here the PlotXY and SpectrumExplorer packages are described.

PlotXY() is the basic package to plot arrays of data points in the HCSS, and it can be used to plot HIFI spectra as well. It has a lot of options, making the plots highly configurable. Here is an example of plotting a HIFI spectrum:

It is also possible to display spectra without taking apart the data format as is described in the previous section. All Herschel spectra types can be displayed with the SpectrumPlot package.

If spectrum is a Herschel Spectral type (Spectrum1d, Spectrum2d) then:

splot=SpectrumPlot(spectrum, useFrame=1)

will simply display the spectrum along with some standard header information. The useFrame=1 allows for the possiblility of creating a plot without actually viewing it at first, but as the last step. The SpectrumPlot module is build on PlotXY, and so many of the features you would use in PlotXY you can also use for SpectrumPlot. Below are a few examples:

from herschel.ia.toolbox.spectrum.gui import SpectrumPlot
from herschel.ia.gui.plot.renderer.StyleEngine.ChartType import HISTOGRAM,LINECHART 
#
#
Creating the plot
sp=SpectrumPlot(spectrum,useFrame=1)
#
#
adding a second spectrum to the plot
sp.add(spectrum2)
#
#Start
fresh again
p = SpectrumPlot(spectrum, useFrame=1)
#
#get
graphs 
g0 = p.getGraphs()[0] 
g2 = p.getGraphs()[2]
#
#display as line graph or histogram
g0.layer.style.chartType = HISTOGRAM 
g2.layer.style.chartType
= LINECHART 
#
#add
annotations 
g0.layer.addAnnotation(Annotation(4000,1,"My
annotation")) 
g0.layer.addAnnotation(Annotation(5000,0.98,"My
annotation")) 
#
#select
a range of data
g0.layer.xaxis.addMarker(AxisMarker(4200,4400)) 
g2.layer.xaxis.addMarker(AxisMarker(6000,6500))

These last lines will produce the following plot:

Figure 4.1. 

The SpectrumExplorer package is based on the PlotXY package, but allows the user to visualize SpectrumDatasets in a friendlier, interactive way. To use it, open the DatasetInspector and click on a SpectrumDataset in the left panel. This will plot the spectrum. If the SpectrumDataset is wrapped in a product, you will have to extract it first. Click on the product in the left panel of the DatasetInspector and then click on a SpectrumDataset in the right panel with the right mouse button. Then click on the blue pop-up window "add to left side". Alternatively, determine the index of the SpectrumDataset you want to extract and at the JIDE prompt enter:

myspectrumdataset=myproduct.get(index)

Then clicking on the SpectrumDataset will show something like this:

In the example, the different colors indicate different WBS sub-bands. Individual sub-bands or individual scans can be plotted by clicking on the appropriate boxes in the bottom panel and removed by double-clicking. Any plot parameter (plot range, titles, colors etc.) can be modified using the right mouse bottom in the same way as for the PlotXY() package. In addition the plot can be modified interactively after clicking the appropriate action button at the top panel. From left to right:

Finally, the SpectrumExplorer package is still under development. Future developments include:

The spectrum arithmetic toolbox allows to combine Herschel spectrum data. Operations are performed either on subclasses of spectrum datasets (Spectrum1d, Spectrum2d), on cubes (SimpleCube, SlicedCube), or on products containing such data structures (e.g., HifiTimelineProduct).

Operations on Spectra include Selection and Arithmetic Operations.

It is planned that the arithmetic toolbox will provide generic functionality for all instruments (HIFI, PACS and SPIRE). Instrument-specific behavior will be pre-configured by defaults in the system but can also be overwritten by the user.

from
herschel.ia.toolbox.spectrum import
SelectSpectrum

ds1 = SelectSpectrum()(ds=data, selection_lookup={"bbtype":[3260]})

Level 0, 1, or 2 products stored in a pool on a local disk can be accessed by ClassLikeTool by entering the following on the HIPE or JIDE command line (or running it from a jython script):

   #import the java class
   from herschel.hifi.dp.gui.spectrum.classliketool import DoClassLikeTool
   #define the pool name that exists on your local disk
   obsid="268435841_sg"
   #register the pool
   storage = ProductStorage()
   pool = PoolManager.getPool(str(obsid))
   storage.register(pool)
   #open ClassLikeTool on the pool
   doclassliketool=DoClassLikeTool(storage)
   

A window will appear on your screen, with buttons to select, plot, fit, and perform various arithmetics operations, which are discussed in the next sections.

Next to the plotting window, three tabs are visible ('Select', 'Arith.', and 'Fit'), which are each discussed in the next three sections. The area below the plotting window shows a number of buttons and boxes that can be used when any of the tabs on the right are selected:

The function of the buttons and boxes shown above is as follows:

The first tab on the right panel of the ClassLikeTool window allows one to select datasets in the pool. As shown in the HIPE screen-shot below a selection can be made between spectrometer backend, obsid, WBS sub-band ("1-4" selects all sub-bands, "1,4" sub-bands 1 and 4), and spectrum dataset type and integration number (in this case numbers 0-10 out of 72 integrations). Clicking the large "Display" button at the bottom creates the plot in the left panel.

In the example shown, the x-axis units are selected with the "X Bottom" button: IF, USB, LSB frequencies or a velocity scale with respect to a frequency entered by the user in a pop-up window. The plot window makes use of the PlotXY package, and thus the plot can be modified using the options under the right mouse button.

A numbers of operations can be performed on the spectra that have been selected in ClassLikeTool (see previous section), by clicking on the "Arith." tab at the top right (see figure below). A particular operation can be un-done with the "Undo" button at the bottom right. If multiple operations have been performed, only the last one can be un-done. The original spectra can still be retrieved using the "Original" button. Plots of the spectra before and after the operation can be made with the "Overlay Previous" button. The following operations are possible using the buttons from top to bottom:

The following HIPE screen-shot shows buttons of all arithmetics options. The integral and RMS noise values were calculated for the areas indicated with vertical grey bars. The latter were defined using the middle mouse button and displayed using the 'Axis Marker' box.

With the third tab on the right, the spectrum can be fitted with polynomials, Gaussians, and Lorentzians. Other functions, including sine waves and Voigt profiles will be added in the future. Fits can be made to regions selected with the middle mouse button and viewed using the 'Axis Marker'. The user can opt for the Amoeba and Levenberg fitter methods, that sometimes give slightly different results. The particular functions to be fitted are selected using the 'Add Component' button. In the example shown below, two Gaussians were fitted. For this instructive purpose, the peak positions ('x0') were assumed to be known to be 0.0 and 200 km/s, and they were fixed to those values by clicking the boxes now showing the 'v' signs (note: presently the option of fixing parameters only works with the Amoeba fitter). Approximate values for 'I0' and 'FWHM' were automatically assigned with respect to the grey area selected with the mouse. The 'Fit' button at the bottom was clicked several times in order to iterate to the best solution.

In the HIPE screen-shot below, the thick blue line represents the data and the green line the Gaussian fits. The residual of data minus fit can be plotted (not done here for clarity) using the "Overlay residual" button.

The Housekeeping (HK) section walks through some basic guidelines to accessing, viewing, and exporting HK data. HK packets have some similarities in structure with the dataframes packets.

Most of the examples are just few lines of the DP code that can be entered at the JIDE prompt, or code fragments or routines designed to serve as an examples for your own programs.

Some limited examples for using the different tasks are given in the help pages for all tasks in Chapter 3. "DP Commands" of the User's Reference Manual.

Please note that it is desirable that trend analysis is carried out at the WBS/HRS pipeline level, as we want to follow trends at the instrument level.

HK data can be both digital and analog.

There are two main methods for obtaining dataframes: by command line access or by a DataSelector GUI. In the first case you will get the frames and put them into an array or table, in the second a more sophisticated method will allow you to access the database (test only with no clear information, at the moment). Below, a basic description for accessing and retrieving dataframes is given.

In 1.1.1 already a brief description of how to get level 0 data is given. Data frames in the database are basically accessed after setting the relevant server and database. Afterwards:

However, with the task ObservationSelector the data frames can be obtained in two additional different ways, by choosing them from the database viewer and selecting the obsid: dataframes = ObservationSelector() (obsid, spectrometer, gui).

To display the values of all digital and analog HK values of the HRS into a JTable:

from herschel.hifi.hrs.task.import *
hkDataset = HrsGetHKTask() (apid=1028, obsid=268494774)
HrsViewHKTask() (model="FM", apid=1028, hk=hkDataset)

To print to an ASCII table file information on periodic HK for LO during an observation:

lo = LO_HK_dump()
t(268494774,5,10)

To print to ASCII table file spectra taken with either WBS. ASCII table spectra also accompanied by a set of useful HK data

t = WBS_Export_ascii()
t(observation=268494774, plot="V")

To read and select data set for an spectrometer (wbs or hrs): observation=ReadObservation()(obsid=5861, spectrometer="wbs-h")

To retrieve system temperature and bandpass/gain determined in a Hot-Cold measurement:

allhot=SelecScans()(spectra,validbbs=Intlb([2223])
allcold=SelecScans()(spectra,validbbs=Intlb([2222])
hot=SingleHifiSpectrum(allhot)
cold=SingleHifiSpectrum(allcold)
ct=ComputeTsys()
noise=ct(hot,cold,eta_hot=0.96)
gamma=ct.gamma

To compute the system temperature using Hot-Cold load results from the HRS:

t = RadioMetry()
t(observation=268494774)

To compute system temperature using Hot-Cold load results from the WBS (across the IF band):

t = RWbs_HotCold_fast_bare()
t(observation=268494774)

To compute the WBS IF noise temperature (across the IF band):

t = Wbs_IFNoise()
ifout=t(observation=268494774)

From the retrieved data frames and HK data a HIFI timeline product can be created. A HifiTimelineProduct is an extension of HifiProduct. It also contains a summary table and a listing of the types of the HSDs.

df = AccessDataFrameTask()(apids=[1030,1031],obsid=268435473)

htp=HifiTimelineProduct(df,hk)

To get start and end time: FineTime start [INPUT, OPTIONAL, default=null] and FineTime end [INPUT, OPTIONAL, default=null], respectively

To retrieve the HK packets containing Gascell information from a database:

Example:

obsids = [268449660, 268449664, 268449665, 268449670]
database = 'ilt_fm_2_prop@iccdb.sron.rug.nl 0 READ'
accessGascellHk = AccessGascellHk()
accessGascellHk.db = database
# for obsid in obsids:
hk_pack = accessGascellHk(obsid = obsid)
print 'obsid', obsid, 'has', len(hk_pack), ' gascell packets.'

To convert HK packets containing Gascell information into a table use the hk_tools.spy and tables_tools.spy routines to create the table. The list of the gascell HK parameters which are tabulated are given in the Chapter 3 of DP Commands.

To generate a table data set of the HK data: TableDataset selected [OUTPUT, OPTIONAL, default=None]

To create a tabla data set of HRS HK converted values (with as many columns as HRS HK mnemonics exist):

from herschel.hifi.hrs.task import *
hk = HrsGetHKTask()(apid=1028, obsid=268435622, type="All")

Helper class for defining the GUI components for AccessHkParamTask:

ahpt = AccessHkParamTask()

ahpt(db=ilt_fm_5_prop@iccdb.sron.rug.nl, obsid=268505167, apid=2017, params = ["FPU_room_temp", "FPU_shutter_temp"])

To store HK information in a PAL: Hk_Store()(obsid=1732, lstore="HK_data", desc="Diplexer scan HK")

As mentioned in the Chapter 4 of the Generic Pipeline description, some HK data are important for the Generic Pipeline. The following HK data are important when processing the generic pipeline:

A list of helpers class for defining the GUI components for the following generic tasks:

A description of the helpers is given in Chapter 3 of the User Manual.

Some parameter names:

Example of how to retrieve them:

from herschel.hifi.generic.task import AccessHkParamTask 
ahpt = AccessHkParamTask()
ahpt(db=ilt_fm_5_prop@iccdb.sron.rug.nl, obsid=268505167, apid=2017, params = ["FPU_room_temp","FPU_shooter_temp"])
composite=ahpt.paramresult
print composite 

# Import needed packages 
from herschel.access import *
from herschel.access.util import *
from herschel.binstruct import *
from herschel.pus import *
# Access HK packets associated with ObsID = 1400
pk = PacketAccess(1400)
# Connect to the default database to find the packets
hk_set = HcssConnection.get(pk)
# Create an empty Java array list - needed for the PacketSequence routine below.
arrList = java.util.ArrayList()
# Loop around adding the HK dataset into the array arrList
for x in range(len(hk_set)):
arrList.add(hk_set[x])
# Look at our array
print arrList
# ...but to get something sensible we need packets in a time order.
pseq = PacketSequence(arrList)
# Get a listing of the parameter types contained in
print pseq
# Find packets in the sequence which contain information on temperatures within the focal plane unit (FPU)
seq_FPU_Temp = pseq.select(TypeEquals("FPU_Temperatures"))
# Find out parameters contained in the selected packets by obtaining the HK parameter names from the first selected packet in the sequence
par_FPU_Temp = seq_FPU_Temp[0].getParametersContained()
# Print out to the DP session the names of all the parameters contained
print par_FPU_Temp
# Choose the FPU Temperature parameter you want to get info on...and get a time ordered set of HK data for it
# The output file plot_fpu_hk is a TableDataset with one column for time (a Finetime of microseconds since 1 January 1958)
# and one for the value of the parameter (RAW rather than engineering value). Here we choose the parameter FPU_b_body_top for the table
# output and get the converted values (in degrees K)
plot_fpu_hk = seq_FPU_Temp.getConvertedMeasures(["FPU_b_body_top"])
time = Double1d(plot_fpu_hk[0].data/1000000.0) # puts time into seconds
data = Double1d(plot_fpu_hk[1].data)
# Plot the timeline of the HK data over the time period of the observation (obsid=1400) by plotting the table
p = PlotXY(time, data, style=Style(line=8, color=Color.black))
# Resize the window
p.height = 400
p.width=600
# Give a layer/legend name...
p[0].name="time plot"
# ...and add a title
p.title.text="FPU temperature"

# Import needed packages for handling databases and HK data
from herschel.access import *
from herschel.access.util import *
from herschel.binstruct import *
from herschel.pus import *
# And this package deals with times.
from herschel.share.fltdyn.time import *
# Enter a start and stop time for HK information. We enter Java Dates, given as year (-1900), Month (-1),
# day, hour, minute, second. Our start_time is therefore 01:10:00 on 25 October 2004
start_time = java.util.Date(104, 9, 25, 1, 10, 0)
# stop_time is 01:15:00 on the same day
stop_time = java.util.Date(104, 9, 25, 1, 15,0)
# Need to convert final numbers into a FineTime used in database.
start_1 = DateConverter.dateToFineTime(start_time)
# Date/time of start for plotted data
prod_date = DateConverter.fineTimeToDate(start_1)
# Ditto for stop time
stop_1 = DateConverter.dateToFineTime(stop_time)
end_date = DateConverter.fineTimeToDate(stop_1)
# Initialize some parameters
pk=0
hk_set = 0
# Get object ready for sorting packets.
pseq = PacketSequence()
# Set up the query for accessing packets of HK data. Here we ask for packets with an APID of 1026, which carries
# HIFI HK data. The database identified by the user's properties is accessed for packets of this type
# between the given start and stop FineTimes.
pk = PacketAccess(1026,start_1,stop_1)
# Now we know where to look, we can get the packets! First we create an array with the packets in
hk_set = HcssConnection.get(pk)
# ...then we loop over the array to get the contents and
# put packets into our packet sequence
for x in range(len(hk_set)):
  pseq.add(PusTmSourcePacket(hk_set[x].getContents()))
# Now we get the parameters in the packets that we can plot.
seq_HIFI_HK = pseq.select(TypeEquals("HIFI_HK_rev_3"))
# Pick out some of them
mnemonics = ["HF_AH1_MXMG_V", "HF_AV1_MXMG_V"]
# ...and get their converted (physical unit) measurements. "plot_HIFI_HK" is a TableDataset with a first column measuring time
# and the next 2 columns holding the HK parameter values at those times. We can now plot any of the parameters versus
# time, or against each other, by picking out the appropriate column of the table.
Plot_HIFI_HK = seq_HIFI_HK.getConvertedMeasures(mnemonics)
# This is what to do to set up the plot. Since time is in microseconds we convert it to seconds first.
# Get the first column and divide by 1 million
time = plot_HIFI_HK[0].data/1000000.0
# Measure time on the plot from the beginning of the observation....We subtract the initial time value
plot_time = time - time[0]
# Plot the two voltages contained in columns 2 and 4
h_voltage = plot_HIFI_HK[1].data
v_voltage = plot_HIFI_HK[2].data
# Plot the data
p = PlotXY(plot_time, h_voltage, style=Style(line=8, color=Color.black))
# Resize the window
p.height = 400
p.width=600
# Change the legend
p[0].name = "H Mixer Plot"
# Change the axis labels...
p.xaxis.title.text="Time (hours)"
p.yaxis.title.text="Mixer voltage [V]"
# ...and add a title
p.title.text="Plot of Mixer Voltages. Start: "+str(prod_date)+\ 
  "End: "+str(end_date)
# Now we can also overlay the second voltage trend in blue.
p[1]=LayerXY(plot_time, v_voltage, name= "V Mixer Plot", \
 style=Style(color=Color.blue))

There are several ways to display the dataframes:

1.-

dd = DisplayDataFrameTask()
dd.dataframe=df[0]
dd.gui = 1

2.-

browse_df = BrowseDfQuery()(gui=1)
#feedback dataframes back into your session using: 
dfs = browse_df.query
df = browse_df.selected
# feedback dataframes back into your session using:
dfs = browse_df.query
df = browse_df.selected

3.-

#to pass an existing store this task should reuse:  
dfs = AccessDataFrameTask()(store=myStore, .....)

The BrowseHK task is used to display HK data associated with an observation stored in any accessable database. To change to a new database type the name of the database into the local database text field located on the database tab. The fastest way to access data from the database is to lookup data using a specific obsid. If the times in the time selector panel are the same the script will automatically get the begin and end time of the observation and add it to the query string. If the times are different this will override the automatic process and search the database based on those times. The execute button is used to aquire data from the database. The exit button is used to close the application.

# interactive mode (Database: ilt_dm_10 obsid: 268435762)
# interactive mode (Database: ilt_fm_2 obsid: 268435480)
from herschel.hifi.generic.task.BrowseHk import *
hkBrowser = BrowseHk()
hkBrowser()
# This only brings up the browser. Once selections are made, and the 
# execute button is pressed, then one can export pk-params(s) in their 
# session
#
# resulting_pks = hkBrowser.query // array[TmSourcePacket]!!
# selected_pk = hkBrowser.selected // TableDataset!!

The array of TmSourcePackets (HK data) returned from the query to the database: Array(TmSourcePacket) query [OUTPUT, OPTIONAL, default=None]

To create a TableDataset of HRS HK converted values: hk = HrsGetHKTask()(apid=1028, obsid=268435622, type="All") or alternatevely TableDataset selected [OUTPUT, OPTIONAL, default=None]

To plot a stream of HK data:

#In a new .py file add the lines (call it qlaHkPlot.py)
from herschel.hifi.generic.process.hkplot import *
DataFlowManager(hkPlot())
Thread.sleep(315360000)  #one year in seconds
#Then from the terminal window type the following
jylaunch qlaHkPlot.py

To plot and export a time series of HIFI HK data for a selected ObsID

HkPlotter()(obsid = obsid, apid = apid) 
HkPlotter()(obsid, apid)

The level 1 data is fed through a pre-processor, which currently does two things:

Spectra can be fed into the deconvolution task in HIPE. As demonstrated in the figure of the HIPE Deconvolution GUI below, only 3 user parameters are required:

All three values are fairly optimized and the user is encouraged to stick with these settings. Pressing ‘run‘ executes the task, and the result is returned as a product.

Alternatively, the deconvolution tool can be run from the command line or in a user jython script. First make sure that the required tasks are imported into your session as follows:

   from herschel.hifi.pipeline.product import HifiTimelineProduct
   from herschel.ia.task import Task
   from herschel.ia.task import TaskParameter
   from herschel.hifi.dp.deconvolution import DoDeconvolution
  

Then the tool can be run either with the default values

decon_result=doDeconvolution(htp=my_htp)

or with user-specified values

decon_result=doDeconvolution(htp=my_htp, bin_size=0,5, max_iterations=200, tolerance=0.001)

A description of the user input variables is given in the previous section (Step 2A).