
::	350um		@Instrument: SHARC-2
			Specify that the 350um filter was used (default). This 
			adjuts conversion factors, tau scaling relations for 
			calculating in-band line-of sight opacitites, and beam 
			sizes (see 'sharc2/default.cfg').
			@See: 'jansky', 'tau.<?>', 'beam'.

::	450um		@Instrument: SHARC-2 
			Use if the 450um filter was used to observe.
			@See: '350um' and '850um'

::	850um		@Instrument: SHARC-2 
			Specify that data was taken at 850um.
			@See: '350um' and '450um'

::	accel		@Alias -> 'correlated.accel-mag'
		 	Can be used to enable acceleration response 
			decorrrelation, or to set options for it.
			@See: 'correlated.<?>' for available options.
	
::	aclip=X		Clip data when the telescope acceleration is above
			X arcsec/s^2. Heavy accelerations can put mechanical
			energy into the detector system, changing the shape of
			the primary, thereby generating bright signals from the 
			varying illumination of the bright atmosphere. Clipping 
			data when there is danger of this happening is a good 
			idea. 
			@See: 'accel' for possible modeling of these signals)

::	alias.<?>	Use to define convenient shorthands for yourself. Aliases
			are literal substitutions. Thus:

			    alias.altaz system=horizontal		
			
			can specify 'altaz' to serve as a shorthand for the
			key/value pair 'system=horizontal'. Conditional can also
			be aliased. E.g.:
			
			    alias.final iteration.[last]

			Defines 'final' as a shorthand for 'iteration.[last]'.
			Thus:
			
			    final:smooth=9.0

			is understood as being 

			   iteration.[last] smooth=9.0

			(The colon provides an alternative to a white-space to
			separate the condition from the statement, which is also
			command-line friendly).
			@See: 'altaz', 'final'   

::	altaz		@Alias -> 'system=horizontal' 
			Shorthand for reducing in Alt/Az cordinates.
			@See: 'system' and 'horizontal'.

::	amps		@Alias -> 'correlated.amps'
			@Instrument: LABOCA
			Decorrelate on amplifier boards, or set options for it.
			@See: 'correlated.<?>' for details on brached options.

::	array		@Alias -> 'correlated.array'
			Decorrelate on all the radiation-sensitive channels of
			the instrument, or set options for it.
			@See: 'correlated.<?>' for details on brached options.
	
::	azymuth		@Alias -> 'correlated.telescope-x'
			Remove signals, which are correlated to the azymuth
			movement of the telescope (e.g. superconducting detector
			arrays sensitive to Earth's magnetic field.),
			@See: 'correlated.<?>' for details on brached options.

::	beam=X		Set the instrument beam to X arcseconds.
			@See: 'resolution'

::	beammap		Effectively the same as 'source.type=beammap', which is
			invoked by a condition, not an alias because aliasing
			would interfere with the similarly named 'beammap.process'
			and 'beammap.writemaps' options.
			Used for reducing beam map data. Instead of making a 
			single map from all pixels, separate maps are created for
			each pixel (Note, this can chew up some memory if you have
			a lot of pixels). At the end of the reduction CRUSH
			determines the actual pixel offsets in the focal plane.
			@See: 'source.type', 'map', 'skydip', 'grid'
	
::	beammap.process		Specify that beam-maps should undergo the same
				post-processing steps (e.g. smoothing, clipping
			filtering, etc.) that are used for regular map-making.
			When the option is not set, beam-maps are used in their
			raw maximum-likelihood forms.
			@See: 'beammap', 'beammap.writemaps'

::	beammap.writemaps	Beam maps normally only produce the pixel 
				position information. Use this option if you want
			CRUSH to write individual pixel maps as well, so you can 
			peek at these yourself.
			@See: 'beammap', beammap.process'

::	blacklist=<list>	Similar to 'forget', except it will not
				set options even if they are then specified
			at a later time. This is useful for altogether removing 
			settings from the configuration.
			@See: 'whitelist', 'forget', 'recall', 'remove', 'replace'

::	blank=X		Skip data from modeling over points that have a source
			flux exceeding the signal-to-noise level X. This may
			be useful in reducing the filtering effect around 
			bright peaks. 
			@See: 'clip'.

::	blind=<list>	Specify a list of blind pixels. Use data indeces (e.g.
			backend indeces for APEX) and ranges, in a comma-separated
			form. E.g.:

			   blind 46,70-72,84

			Blind channels may be used by some instruments to
			estimate instrumental signals, such as temperature
			fluctuations (LABOCA). Channels are normally numbered
			from 1 (i.e. not C-style!)
			@See: 'flag'.

::	block=NX,NY	@Instrument: SHARC-2
			Specify a correlated block size for higher order 
			sky-noise removal, as two integer pixel numbers (rows and
			columns) separated by a comma or 'x'. E.g.:

			   block=4x6

			will decorrelate signals on blocks that are 4 columns wide
			and 6 rows tall (i.e. there will be 16 such blocks on the
			32x12 SHARC-2 array).
			@See: 'blocks'

::	blocks		@Alias -> correlated.blocks
			@instrument: SHARC-2
			Decorrelate on rectangular block regions of the array, as
			a way to remove higher order sky-noise. As such, it can 
			be used together with, or instead of 'gradients'.
			@See: 'gradients', 'correlated.<?>'

::	boxes		@Alias -> correlated.boxes
			@Instrument: LABOCA, ASZCA
			Decorrelate on electronic boxes, or set options for it.
			@See: 'correlated.<?>', 'cables', 'squids'

::	bright		Use for bright sources (S/N > ~1000). This setting
			entirely bypasses all filtering to produce a very
			faithful map. The drawback is more noise, but
			that should not be an issue for such a bright guy :-)
			Will invoke 'bright.cfg'.
			@See: 'config', 'faint', 'deep'

::	cables		@Alias -> correlated.cables
			@Instrument: LABOCA, ASZCA
			Decorrelate channels whose signals are running on the 
			same cables, and which are therefore subject to the same 
			pickups (electromagnetic or microphonic).
			@See: 'correlated.<?>', 'boxes'

::	center=dx,dy	Specify relative pointing offsets (in the system of the 
			telescope mount) in arcseconds. In other words, you can
			specify the center offsets of a nearby pointing source
			reduced in the telescope base coordinate system (e.g.
			horizontal). You can easily determine such offsets from
			pointing scans using the 'show' tool provided in the
			CRUSH package. (For APEX uses, this option works like 
			'pcorr' in the control system). 
			Some instruments may define further ways of setting
			pointing offsets.
			@See: 'fazo', 'fzao'

::	chopped		Used for specifying a chopped data reduction. Can be
			set manually or automatically (via 'detect.chopped')
			based on the data itself. The key may trigger conditional
			statements and extra decorrelation steps.
			@See: 'detect.chopped', 'correlated.<?>.trigger'

::	chopper		@Alias -> correlated.chopper-x
			Remove signals that are correlated with chopper movement.
			The moving secondary mirror changes the telescope
			illumination, thus producing strong signals when observing
			under a bright atmosphere. To first order, such signals
			are linear with chopper displacement. Since most
			telescopes chop in the horizontal 'x' direction only, the
			'chopper' keyword is aliased to decorrelation on motion
			in that direction. When a 2D chopper is used, you should
			decorrelate in both the 'x' and 'y' directions.
			@See: 'decorrelate.<?>', 'detect.chopped'

::	clip=X		In early generations of the source map, force map
			pixels with flux below signal-to-noise level X to zero.
			This may help getting lesser baselines, and filtering 
			artefacts around the brighter peaks. Often used together
			with 'blank' in the intermediate iterations.
			@See: 'blank', 'iteration.[?]'

::	config=<filename>	Load the configuration file filename. 
				The file is looked for in the locations in the
				following order:

					1. ./
					
					2. ./<instrument>/

					3. ~/.crush2/

					4. ~/.crush2/<instrument>/

			Whenever a matching file is found its contents are 
			parsed. Because of the ordering, it is convenient to 
			create overriding configurations.
			Thus instrument specific settings can be used to override
			common defaults, and user specific settings placed in 
			'~/.crush2' can override the distribution defaults. 
			Whenever a configuration is parsed, there is a note of it
			on the console output so that one always knows which 
			files were read and in what order. E.g. when using
		
			   > crush laboca 12066

			the following configuration files will be loaded in order
			(provided they exist):

			    {$CRUSH}/default.cfg
			    {$CRUSH}/laboca/default.cfg
			    ~/.crush2/default.cfg
			    ~/.crush2/laboca/default.cfg
				  
			Each successively loaded file may override the options 
			set before it.
			@See: 'bright', 'faint', 'deep'


::	correlated.<?>	Remove the correlated noise term accross the entire
			array. The <?> stands for the name of the modality on
			which decorrelation is performed. E.g. 'obs-channels', 
			'gradients', 'squids' (ASZCA, GISMO or SABOCA), or 'rows'
			(SHARC-2). 
			This is an effective way of dealing with most 
			atmospheric, and instrumental signals, such as sky noise,
			ground pickup, temperature fluctuations, electromagnetic
			or microphonic pickups. The decorrelation of each
			modality can be further controlled by a number of subkeys
			(see below). 
			The given decorrelation step must also appear in the
			pipeline 'ordering' before it can be used.
			@See: 'modality', 'ordering'

::	correlated.<?>.gainrange=min:max	Specify a range of acceptable
						gains to the given correlated
			signal <?>, relative to the 'average' gain response of
			the correlated mode. Channels that exhibit responses
			outside of this range will be appropriately flagged in 
			the reduction, and ignored in the modeling steps until
			the flag is revised and cleared in another decorrelation
			step.
			@See: 'division.<?>.gainflag', 'correlated.<?>.signed'

::	correlated.<?>.nogains		Disable the solving of gains (i.e. channel
					responses) to the correlated signal <?>.

::	correlated.<?>.nosignals	Disable the solving for correlated signal
					<?>, whose value stays fixed afterwards.

::	correlated.<?>.resolution=X     Set the time resolution (in seconds) for 
					the decorrelation of <?>. When dealing
			with 1/f-type signals, you probably want to set this to
			the 1/f knee time-scale or below if you want optimal
			sensitivities. Else, you may want to try larger values
			if you want to recover more large-scale emission and
			you aren't too worried about the loss of sensitivities.
			@See: 'extended'
			
::	correlated.<?>.signed		By default gain responses are allowed to
					be bidirectional, and flagging affects
			only those channels or pixels, whose absolute gain values
			fall outside of the specified range. When 'signed'
			is set, then gains are flagged with the signs also taken
			into account. I.e., under 'signed', 'gainrange'
			of '0.3:3.0' would flag pixels with a gain of -0.8,
			whereas the default behaviour is to tolerate them.
			@See: 'correlated.<?>.gainrange', 'correlated.<?>.nogains'

::	correlated.<?>.trigger=<key>	You can specify a configuration key that
					is to serve as a trigger for activation
			the decorrelation of <?>. This is used, for example to
			activate the decorrelation of chopper signals, if and
			when the 'chopped' keyword is specified. E.g.:

			   chopper.trigger=chopped

			@See: 'chopper', 'chopped'

::	correlated.*	You can use wildcards '*' to set options for all
			decorrelation steps at once. E.g.:

			   correlated.*.resolution 1.0
			 
			Sets the time-resolution of all currently defined 
			decorrelation branches (and modalities) to 1 second.
			@See: 'correlated.<?>', 'resolution'

::	datapath=<dir>	Start looking for raw data in directory <dir>. Some
			instruments may also interpret it as a root directory
			in which data may reside some specific hierarchy. E.g.
			in <dir>/<project> for APEX bolometers. Thus, if an
			APEX instrument defines:
				
				datapath /homes/data
				project T-79.F-0002-2007

			then crush will try to find data first in
			'/homes/data', then in '/homes/data/T-79.F-0002-2007'
			This provides a convenient way for accessing 
			hierarchically stored data. See the instrument-
			specific notes for details.
 
::	dataunit=<name>		Specify the units, in which the data are stored.
				Typically, 'counts' or 'V', or any of their
			common multiples, such as 'mV', 'uV' or 'pcount' are 
			accepted. The conversion from data units to jansky-based
			units is set via the 'jansky' option, while the choise
			of units in the data reduction is set by 'unit'.
			@See: 'unit', 'jansky'

::	date=YYYY-MM-DD	      	@Instrument: GISMO
				Specify the date of observation for GISMO data, 
			which can be used along with 'object' to help locate scan
			data using scans numbers (and ranges). The date must be 
			given in the specified format, identical to the one 
			appearing in the standard IRAM scan IDs.
			@See: 'object', 'read'

::	date.[...]	A way to set date specific conditional statements. Inside
			the square brackets one can specify a date range in
			YYYY-MM-DD format, separated by a colon ':' or hyphen(s)
			'-'. Wildcards '*' are also accepted to specify open
			ranges. E.g.:

			  date.[2009.12.10--*] instrument.gain=-1000.0

			Can be used to specify an inverted thousand-fold
			instrumental gain starting from Dec 10, 2009.
			@See: 'mjd', 'serial'

::	deep		Use for very faint sources which are not at all 
			detected in single scans, or if you think
			there is too much residual noise (baselines) in your 
			map to your liking. This setting results in the most 
			agressive filtering. Will load the configuration from
			'deep.cfg'. The output map is optimally filtered
			(smoothed) for point sources.
			@See: 'config', 'bright', 'faint'

::	despike		Use despiking. CRUSH allows the use of up to three
	 		different despiking steps, each configurable on its
			own, to specify a despiking method, S/N level and
			flagging criteria. See the various despiking options
			below:

::	despike2	A second round of despiking.
			@See: despike

::	despike3	A third round of despiking.
			@See: despike

::	despike.flagcount=N	Tolerate (w/o pixel flagging) up to N spikes up
				in each pixel.

::	despike.flagfraction=X	Tolerate (w/o pixel flagging) spikes up to 
				fraction X of the scan frames in each channel.
				
::	despike.framespikes=N	Tolerate up to N spikes per frame.
	
::	despike.level=X		Despike at an S/N level of X.	

::	despike.method=<name>		CRUSH offers a choice of despiking
					methods to choose from. Each of these
			have their own pros and cons, and may produce different
			results and side-effects in different environments. The
			following methods are currently available:

			   neighbours  Despike only by comparing neighbouring 
			   	       samples of data from the same channel.

			   absolute    Flag data that deviates by the specified
			   	       S/N level.

			   gradual     Like 'absolute' but proceeds more 
			   	       cautiously, removing only a fraction of
				       most offending spikes at each turn.

			   features    Look for spikes wider than just a sigle 
			   	       sample. The 'width' subkey (below) 
				       the timescale, up to which spikes sought.

			All methods will flag pixels and frames if these have too 
			many spikes. The flagging of spiky channels and frames
			is controlled by the 'flagcount, 'flagfraction' and
			'framespikes' subkeys.
			@See: 'despike.flagcount', 'despike.flagfraction',
			      'despike.framespikes', 'despike.level',
			      'despike.width'

::	despike.width=X	      When despiking using the 'features' method, spikes 
			      up to X second in width will be sought.
				
::	detect.chopped	      Try determine from the data itself if the chopper 
			      was used, and set the 'chopped' flag accordingly. 
			This can be used to trigger the actication of specific 
			reduction steps for chopped data.
			@See: 'correlated.<?>.trigger'

::	division.<?>=<list>   Specify a new pixel division <?> from a list of
			      pixel groups, separated by commas. For example, if
			the pixel groups 'my-pixels-1' and 'my-pixels-2' were
			defined (via 'group.<?>') then the line

			   division.my-division my-pixels-1,my-pixels-2
			   
			creates a division from these two groups. For every
			division created this way, CRUSH will also create a
			correlated modality with the same name.
			@See: 'correlated.<?>', group.<?> 

::	division.<?>.id=<ID>	 Specify a designated ID for the pixel division
				 <?>. This short ID will be printed on the console
			output, whenever the decorrelation step on the modality
			<?> is performed in the reduction.
			@See: 'correlated.<?>'

::	division.<?>.gainfield=<name>	You can also specify the name of an 
					existing JAVA double field inside the
			pixel class of the given instrument to serve the gains
			for the decorrelation of <?>. Unless 
			'correlated.<?>.nogains' is also specified, these gains
			will be determined and overwriten each time the 
			decorrelation takes place.
			@See: 'correlated.<?>.nogains'

::	division.<?>.gainflag=N		Specify a gain flagging pattern to use
					when flagging outlying gains in the
			decorrelation step of <?>. Gain flags are normally one
			bit in a 4-byte integer, and can be specified using
			octal ('0' prefix) or hexadecimal ('0x' prefix) numbers
			as well as regular integers. You should be careful not
			to interfere with existing flags, many of which may be
			hardcoded in the JAVA source. Use with extreme caution,
			if you must...
			@See: 'correlated.<?>.gainrange'

::	downsample=X	Downsample the data by a factor of N. At times the
			raw data is sampled at unnecessarily high frequencies.
			By donwsampling, you can ease the memory requirement
			and speed up the reduction. You can also set the value
			to 'auto' (default), in which case an optimal downsampling
			rate is determined based on the typical scanning speeds,
			s.t. the loss of information will be insignificant due to
			unintended smearing of the data.

::	drifts=X	Filter low frequencies below the characteristic 
			timescale of X seconds. An effective way of dealing 
			with 1/f noise.
			You can also use 'auto' to determine the filtering
			timescales automatically, based on 'sourcesize', scanning
			speeds, and instrument 'stability' time-scales.
			Drift modeling
			@See: 'sourcesize', 'stability', 'offsets
	
::	drifts.method=<name>	Choose the method, with which drifts are removed.
				The choice is between 'blocks' or 'fft'. The
			former estimates and removes drifts from the timestreams
			in consecutive time windows (i.e. blocks) of data. This
			is very fast, and scales linearly with data size. The
			'fft' method implements a spectral lowpass filter, with
			the same characteristic timescale as the other method.
			It is slower, and its computation requirement scales with
			N log N.

::	ecliptic	@Alias -> system=ecliptic
			Reduce using ecliptic coordinates (for mapping).
			@See: 'system', 'altaz', 'equatorial'

::	elevation-response    @Instrument: SHARC-2
			      Load and use an lookup table for the elevation 
			dependent forward efficiency of the telecscope. The table
			is an ASCII file, as specified by Darren Dowell, and is 
			available from the SHARC-2 web-site. CRUSH contains 
			copies of the available tables and is configured to use 
			them as needed.

::	epoch=X		@Instrument: GISMO
			Normally the coordinate epoch, in which the equatorial 
			source coordinates are expressed, is stored in the data. 
			However, for GISMO runs 1 and 2, this information was 
			handled incorrectly. This option provides the means to 
			correct that. The value can specify a year (e.g. 1950.0, 
			or 2000.0), or a proper epoch designation (e.g. B1950, or
			J2000). IRAM uses J2000 for static sources and the 
			current epoch for solar system objects.

::	equatorial	@Alias -> system=equatorial
			Reduce using equatorial coordinates (for mapping).
			@See: 'system', 'altaz'

::	estimator=<type>	'median' or 'maximum-likelihood' estimators to
				use in deriving signal models. 'median' 
			estimators are less sensitive to the presence of bright 
			sources in the data, therefore it is the default for
			when 'bright' is specified (see 'bright.cfg'), and for
			some instruments (e.g. GISMO)
			When medians are used, the corresponding models are 
			reported on the console output in []'s...
			(see the Console Output section of the README).
			@See: 'gains.estimator', 'weighting.method'

::	exposureclip=X  Flag (clip) map pixels whose relative time coverage
			is less than the specified value X. This is helpful for
			discarding the underexposed noisy edges of the map.

::	excessload=X	@Instrument: SHARC-2 
			SHARC-2 can determine a line-of-sight opacity based on 
			the total-power response of its detectors. However, for 
			this to work well, all sources of optical loading on the 
			detectors must be understood. The load curves (see 
			'response') were determined at one time only, and 
			therefore this flag provides the means to specify a
			different optical loading environment from then, as an
			excess optical load (in Kelvins).
			@See: 'response', 'tau.<?>'

::	extended	Try to better preserve extended structures. This
			setting can be used alone or in combination with
			a brightness options. The fainter settings the more 
			difficult it is to recover extended emission. For bright 
			structures recovery up to FOV (or beyond!) should be 
			possible, while for faint structures ~1/4 FOV - FOV 
			scales are maximally obtainable (see more on this in the 
			README).
  			@See: 'sourcesize', 'bright', 'faint', 'deep'

::	faint		Use with faint sources (S/N < ~30) when the
			source is faint but still visible in a single scan. 
			This setting applies some more aggressive filtering of 
			the timestreams, and extended structures. It invokes 
			'faint.cfg'.
			@See: 'bright', 'deep'

::	fazo		@Instrument: SHARC-2 
			An alternative to 'center' for providing pointing 
			corrections. As opposed to 'center', which specifies 
			incremental corrections, this option takes an absolute 
			AZ pointing offset (i.e. FAZO at the CSO) which should 
			have been the correct one (as opposed to the value used
			by the antenna computer during the observations).
			@See: 'fzao', 'center'

::	febe		@Instrument: APEX
			Defines the frontend-backend combination to use. 
			E.g. for LABOCA, this would be set to 'LABOCA-ABBA'.

::	final:key=value	    @Alias -> iteration.[last]
			    When used on the command line, a ':' can be used as
			a sepatation between the abbreviated condition and its
			statement. E.g.:

			   > crush [...] -final:smooth=beam

			to specify beam smoothing in the last iteration.

::	flag=<list>	Specify a list of backend channels that ought to be 
			ignored for the successively read scans. Can use pixel
			numbers (i.e. APEX backend indexes) and ranges. E.g.:

			   flag 5-10,12,33-37
			   
			Indeces normally start at 1 (i.e. not C-style!).
			@See: 'noslim', 'blind' 

::	forget=<option>...	Forget the priorly set values for <option> as if 
				it were never defined. E.g. 
		     		
					forget=outpath

			will unset the 'outpath' option. You can specify more 
			than one options as a comma-separated list. E.g.
	
					forget=outpath,project
				
			With unset both the 'outpath' and 'project' options.	
			Forgotten values may be 'recall'-ed.
			@See: 'recall', 'blacklist', 'remove'

::	frames=<from>-<to>  Read only frames <from>-<to> from the data. Maybe
			useful for quick peeks at the data without processing
			the full scan, or when a part of the data is corrupted.

::	fzao		@Instrument: SHARC-2
			Specify a zenith pointing offset.
			@See: 'fazo'

::	gain=X     	Specify an instrument gain of X from the detector stage 
			(or fixed signal stage) to the readout. Many instruments 
			may automatically determine the relevant gain based on 
			their data headers. For others, the gains may have to be 
			adjusted by hand, especially if they are changing. Upon 
			reading the scans, CRUSH will divide all data by the 
			specified value, to bring all scans to a comparable 
			signal level. Conversions to 'jansky' are referenced to 
			such gain-scaled data.
			@See: 'jansky', 'dataunit', 'scale'

::	gainnoise	

::	gains		Solve for pixel gains based on their response to the
			correlated noise (above). If not specified, then
			all decorrelation steps will proceed without gain 
			solution. A model-by-model control is offered by the
			'correlated.<?>.nogains' option.
			@See: 'gains.estimator', 'correlated.<?>.nogains'

::	gains.estimator=<type>	Specify the type of estimator ('median' or
				'maximum-likelihood') to be used for estimating
			pixel gains to correlated signals.
			@See: 'estimator', 'correlated.<?>'

::	galactic 	@Alias -> system=galactic
			Reduce using new galactic coordinates (for mapping).
			@See: 'system', 'equatorial', 'altaz'

::	gradients	@Alias -> correlated.gradients
			Shorthand for the decorrelation of gradients accross the
			detector array. Such gradients can occue as a result of
			spatial sky-noise, or as temperature variation across the
			detectors.
			@See: 'correlated.<?>', 'blocks'			
	
::	grid=X		set the map pixelization to X arcsec. Pixelization
			smaller than 2/5 beam is recommended. The default is
			~1/5 beam pixelization.

::	group.<?>=<list>     Specify a list of channels, by index, that belong
			     to a group with name <?>. The list can contain
			comma separated list of indeces (starting with 1) and
			ranges. E.g.:

			  group.my-group 10-20,45,50-60
			    	
			defines a group named 'my-group' from the specified
			channels.
			@See: 'division'

::	he3=<source>	@Instrument: LABOCA
			Correct time-streams for He3 temperature fluctuations. 
			<source> specifies the source of the He3 data, which can 
			be 'thermistor' or 'blinds'. The use of blind bolometers 
			is quicker and preferred, unless you specifically wish to
			use the 'thermistors'.

::	he3.calc	@Instrument: LABOCA
			Specifies that rather than correcting for temperature 
			fluctuations, the thermistor and bolometer data should be
			used to calculate appropriate temperature gains. This 
			option should only be used on skydip scans with the 
			shutter closed (i.e. only temperature signals without 
			sky). Additionally 'forget=source' should be used to 
			disable source modeling for such data.

::	he3.gains	@Instrument: LABOCA

::	he3.maxrms	@Instrument: LABOCA
	
::	horizontal	@Alias -> system=horizontal
			Reduce in horizontal coordinates (for mapping).
			This is often useful for determining pointing offsets
			or for beam mapping.
			@See: 'system', 'center', 'beammap', 'fazo', 'fzao'

::	indexing	Allows the use of data indexing to speed up coordinate
			calculations for mapping. Without indexing the map
			coordinates are calculated at each mapping step. This can
			be slow because of the complexity of the spehrical
			projections, which often require several complex math
			evaluations. With indexing enabled, the calculations
			are performed only once, and the relevant data is stored
			for reuse. However, the storage of indexes more or
			less doubles the memory requirement of CRUSH. Thus, 
			'indexing' may be disabled for very large reductions.
			Alternatively, one may control the amount of memory such
			indexes may use, via the 'indexing.saturation' option.
			@See: 'indexing.saturation', 'grid'

::	indexing.saturation=X 	Specify the maximum fraction X of the total
				available memory that can be filled before
			indexing is automatically disabled. Given a typically 20%
			overhead during reduction, values below 0.8 are
			recommended to avoid overflows. 
			@See: 'indexing'

::	invert		Invert signals. This setting may be useful in creating 
			custom jackknifes, where the user wishes to retain 
			control over which scans are inverted.
			@See: 'gain', 'scale', 'jackknife'

::	iteration.[N]	Use as a condition to delay settings until the Nth
			iteration. E.g.

			   iteration.[3] smooth halfbeam

			or 

			   > crush [...] -iteration.[3]smooth=halfbeam [...]
			 
			to specify half-beam smoothing starting from the 3rd
			iteration.
			@See: 'iteration.[?]'

			
::	iteration.[last]    Specify settings that should be interpreted only
			    at the beginning of the last iteration.
			    @See: 'iteration.[?]'
	
::	iteration.[last-N]  Activate settings N iterations before the last
			    one. E.g.
			    
			       iteration.[last-2] forget=clip

			Disables clipping two iterations before the last one.	
			@See: 'iteration.[?]'

::	iteration.[X%]	    Activate settings as a percentage X of the total
			    number of iterations (as set by 'rounds'). E.g.
			
				iteration.[50%] forget clip

			can be used to disable the S/N clipping of the source map
			half way through the reduction.
			@See: 'iteration.[?]'

::	iteration.[?]	Apply settings at the beginning of specific iterations. 
			Because of the flexible syntax, the same iteration can be
			referred to in different ways. Consider a reduction with 
			10 rounds. Then,

				iteration.[5] smooth 5.0
				iteration.[50%] smooth 10.0
				iteration.[last-5] smooth beam

			can all be used to define what happens in the 5th
			iteration. CRUSH will parse these conditionals in the 
			above order: first the explicit iteration settings then 
			those relative to the reduction length, and finally the 
			settings relative to the end of the reduction. Thus, in 
			the above example the beam smoothing will always override
			the other two settings.
			@See: 'iteration.[N]', 'iteration.[X%]', 
			      'iteration.[last]', 'iteration.[last-N]'


::	jackknife	Jackkniving is a useful technique to produce accurate 
			noise maps from large datasets. When the option is used 
			the scan signals are randomly inverted, s.t. the source 
			signals in large datasets will tend to cancel out, 
			leaving one with pure noise maps.
			The sign inversion is truly random, s.t. repeated runs
			with the 'jackknife' flag will produce a different 
			jackknife every time. If you want more control over which
			scans are inverted, consider using the 'invert' flag
			instead.
			@See: 'invert', 'scramble'


::	jansky=X	Specify the calibration factor from data units to Jy.
			@See: 'dataunit', 'gain', 'jansky.inverse'.

::	jansky.inverse	When used, the 'jansky' definition is inverted to mean
			Jy to data unit. This used to be the old definition used
			in crush-1.xx and minicrush.
			@See: 'jansky'

::	log		

::	log.format

::	maitau.fallback=<type>	@Instrument: SHARC-2
				Define which tau value to use in case the MaiTau
			lookup fails. The possible values are:

			   direct 	  Calculate tau from the total-power
			       		  loading of the detectors

			   225GHz	  Use the 225GHz tipper value.

			   350um	  Use the 350um tipper value.

			   sharc2	  Use the value specified by tau.sharc2

			Other than the 'direct' flag, the values may be specified
			with the corresponding tau settings.
			@See: 'maitau.server', 'tau.225GHz', 'tau.350um',
			      'tau.sharc2'

::	maitau.server=IP      @Instrument: SHARC-2
			      Specify the MaiTau server to use, either as an IP
			address, or server name. This should probably be set to 
			'agn.caltech.edu', or to the equivalent 
			'fangorn.submm.caltech.edu'. MaiTau is a server-based
			lookup of the CSO opacities, based on dailly polynomial
			fits to the measured 225GHz and 350um tipper data. The
			polynomials smooth out short-term fluctuations and 
			measurement errors, providing a smoothly varying function
			of tau with time. When using MaiTau, CRUSH will try use
			the 350um fit, and then the 225GHz fit (if available),
			from which it calculates an appropriate in-band zenith
			tau value.
			@See: 'tau.<?>.a', 'tau.<?>.b'

::	mappingfraction=X     Specify a minimum fraction of pixels in the array
			      that have to remain unflagged for creating a map
			from the scan. If too many pixels are flagged in the
			reduction, it may be a sign of bigger problems, 
			questioning the reliability of the scan data. It is best
			to skip over problematic scans in order to minimize their
			impact on the mapping.
			@See: 'mappingpixels'

::	mappingpixels=N	      Specify a minimum number of pixel, which have to
			be unflagged by the reduction in order for the scan to
			contribute to the mapping step
			@See: 'mappingfraction'

::	map.size=X,Y	Explicitly set the size of the mapped are, centered on 
			the source to and X by Y arcseconds rectangle. Normally,
			the map size is automatically calculated to contain all
			of the data. One may want to restrict mapping to smaller
			regions (outside of which, there should be no bright
			sinals). The letter 'x' may also be used instead of the
			comma to separate the dimensions. E.g.:

			   map.size=300x200

			will restrict mapping to a 300" by 200" are (in the 
			chosen coordinate system of the mapping), centered on
			the nominal source coordinates.
			@See: 'system'

::	mjd.[...]	Specify settings that are conditionally activated if and
			when the MJD of the scan falls within the specified range
			inside the square brackets. Wildcards '*' can be used to
			indicate open ended ranges. E.g.:

			       mjd.[*-54230.25] jansky=5.0

			specifies that up until 6:00 UT on 10.05.2007, the 
			conversion factor of 5.0 data units per Jy should be
			used.
			@See: 'date.[...]', 'serial.[...]'

::	mux		@Alias -> decorrelate.mux
			@Instrument: SHARC-2, GISMO
			Decorrelate on MUXes, or set options for it.
			@See: 'decorrelate.<?>'

::	name=		Specify the output image file name, relative to the
			directory specified by 'outpath'. When not given
			minicrush will chose a file name based on the source
			name and scan number(s), which is either

				<sourcename>.<scanno>.fits

			or
	
				<sourcename>.<firstscan>-<lastscan>.fits

			For mapping. Other source model types (e.g. skydips
			or beam maps) may have different default naming 
			conventions.
			@See: 'outpath'


::	noiseclip=X	Flag (clip) map pixel with a noise level that is more
			than X times higher than the deepest covered parts
			of the map.
			@See: 'exposureclip', 'clip'

::	nogaps[=JSharc]		@Instrument: SHARC-2
				Terminate the reading of the data at the first 
			gap. During the early SHARC-2 runs when JSharc was used 
			for the acquisition of the data, there was an occasional 
			damaging timing bug resultuing from the wraparound of an 
			internal buffer. The bug manifested in a sudden jump in 
			the timestamps, making it relatively easy to diagnose if 
			this happened during the scan.
			The optional argument 'JSharc' restricts the gap 
			termination to data obtained using 'JSharc' alone
			(default).

::	noresistors	@Instrument: LABOCA
			Do not use the resistor channels in the decorrelation of
			electrinic signals, such as 'boxes', 'cables' and 'amps'.
			In LABOCA several of the readout channels are connected
			not to light-sensitive detectors, but to fixed resistors.
			While these are not sensitive to radiation or temperature
			the channels will still be subject to electronic pickup.
			Therefore, the default is to use these channels when
			decorrelating signals, which are thought to originate
			within the electronics. This option can be used to 
			overrride this behavior, and restrict all decorrelation
			steps to detector channels only.
			@See: 'boxes', 'cables', 'amps'
		
::	noslim		After reading the scans, CRUSH will discard data from
			from channels flagged with a  harware problem (any bit in
			0xFF), to free up memory, and to speed up the reduction.
			This option overrides this behaviour, and retains all
			channels for the reduction, whether these are used or not.

::	object=<name>	@Instrument: GISMO
			Can be used to help locate GISMO data with scan numbers
			when used together with the 'datapath' and 'date' options.
			E.g.:
			
			  > crush [...] -datapath=. -object=Mars \
			    -date=2010-04-15 12-14

		 	Will reduce Mars scans 12 to 14 from Apr 15, 2010. The
			object name is case-sensitive!
			@See: 'datapath', 'date'

::	obslog

::	obslog.format

::	offsets		Remove the residual DC offsets from the bolometer 
			signals (ignored when 'drifts' below is also 
			specified.)
			@See: 'drifts'

::	ordering=a,b,c	Specify the order of pipeline elements as a comma
			separated list of keys.
			@See: 'offsets', 'drifts', 'weighting', 'despike'
			      'source', 'decorrelate.<?>', 'whiten',
			      'time-weighting'

::	outpath=<path>	Set the directory into which output files (e.g. maps) 
			will be written. Can use '~' for home directory and 
			environment variables in {}'s. Thus,

			   outpath=~/images

			and

			   outpath={$HOME}/images

			are equivalent.
			@See: 'name', 'datapath'

::	ortho		@Instrument: PolKa
			Specify that the orthogonal (a.k.a vertical) analyzer was
			used for taking the data. Specifying the analyzer is
			important for recovering the polarization information.
			Currently the analyzer position is not recorded in the
			data files, although the plan is to have this capability
			in the future. Currently, therefore, this option is
			necessary to distinguish between the two analyzer grids.

::	outpath=<path>	Specify the output path, where all CRUSH output will be 
			written (including maps etc.). Path names follow the
			usual rules (See 'Basic Configuration' section in the
			README), and can use '~' to refer to the home directories
			or to environment variables in {} brackets with a $ sign.
			E.g.

				outpath={$HOME}/images

			in UNIX specifies the 'images' subdirectory inside a
			user's home.

::	pcenter=row,col	       @Instrument: SHARC-2, GISMO
			       Defines the pointing center used, in terms of the
			instrument pixel row and colum coordinates. Pixel 1,1
			designates the top-left corner of the array in horizontal
			(AZ/EL) or equivalent Nasmyth coordinates. Columns
			increase to the right, while row numbers increase 
			downward. Thus, the center of the SHARC-2 array is 
			6.5,16.5, while the center of GISMO is 8.5,4.5.
			The 'pcenter' option is not used if the pixel positions
			are loaded from an RCP data file, instead of being
			calculated (since a rectangular grid can no longer be
			assumed).
			@See: 'rcp', 'rcenter', 'pixelsize', 'rotate'

::	pins		@Alias -> correlated.pins
			@Instrument: GISMO
			Decorrelate on readout address lines (across the MUXes)
			or set options for it.
			@See: 'decorrelate.<?>', 'pins.group', 'mux'

::	pins.group=N	@Instrument: GISMO
			Based on the 'pins' alias for GISMO, it defines a grouping
			of N neighbouring address lines. For each MUX, there are
			32 address lines, which are read out sequentially in the
			time-domain multiplexing scheme. Thus,

			   pins.group=4
			   
			will group the address lines 1-4, 5-8, ..., 29-32 together
			across all MUXes, thus increasing the number of channels
			in each group. The decorrelation of address lines using
			the 'pins' option will take place on these groups.
			@See: 'pins', 'mux'

::	pixeldata=<filename>	Specifies a pixel data file, providing initial
				gains, weights and flags for the detectors,
			and possible other information as well depending on the
			specific instrument. Such files can be produced via the
			'write.pixeldata' option (in addition to which you
			may want to specify 'forget=pixeldata' s.t. flags are
			determined without prior bias).
			@See: 'gainnoise', 'uniform', 'flag', 'blind'

::	pixelsize=X,Y	@Instrument: SHARC-2, GISMO
			Specify the size of rectangular pixels in a grid. This
			is used for calculating pixel positions on a rectangular
			grid. The information is ignored when positions are
			loaded from an RCP data file (as a regular grid can no 
			nonger be assumed).
			@See: 'rcp', 'pcenter', 'rcenter'


::	poll[=key]	Whenever unsure what options are set at any given stage, 
			you can poll the settings. Without an additional argument
			it will list all currently defined setting to the 
			standard output. When an argument is specified it will 
			list the configuration settings that start with the 
			specified string. E.g.

				> crush [...] -poll=despike
	
			will list all despiking options that have been defined
			prior to the invokation of the '-poll' command.

::	positions.smooth=X    Specify that the telescope encoder data should be
			      smoothed with a time window X seconds wide, in 
			order to minimize the effects on encoder noise on the
			calculation of scanning speeds and accelerations, based
			on which data may be discarded, and optimal downsampling
			rates are determined.
			@See: 'aclip', 'vclip', 'downsample'

::	project=<id>    @Instrument: APEX
			Some instruments (e.g. APEX bolometers) may require a 
			project ID to be set in order to locate scans by serial 
			number. Use capitalized form when defining APEX projects.
			E.g.,

                              project T-79.F-0002-2007


::	projection=	Choose a map projection to use. The following projections
			are supported:

				SIN  --  Slant Orthographic
				TAN  --  Gnomonic
				ZEA  --  Zenithal Equal Area
				SFL  --  Sanson-Flamsteed
				MER  --  Mercator
				CAR  --  Plate-Carree
				AIT  --  Hammer-Aitoff
				GLS  --  Radio (aka Global Sinusoidal)

			@See: 'system', 'grid', 'mapsize'

::	radec		@Alias -> system=equatorial
			Reduce using equatorial coordinates (for mapping).
			(Default)
			@See: 'system', 'altaz'

::	rcenter=dX,dY	@Instrument: SHARC-2
			Specify a rotation center, in the coordinate system of
			the array (AZ,EL or Nasmyth coordinates). Works similarly
			to 'pcenter'
			@See: 'pcenter'

::	rcp=<filename>	Use the RCP file from <filename>. The usual rules of
			path specification apply (see the 'Basic Configuration' 
			section of the README.). The file should conform to the
			standard IRAM or APEX RCP specs containing the 
			information in ASCII columns. RCP files can be produced 
			by the 'beammap' option, from scans, which move a bright 
			point source over all pixels.
			For rectangular arrays, pixel positions can also be 
			calculated on a regular grid using 'pixelsize' and 
			'pcenter'
			@See: 'beammap', 'pixelsize', 'pcenter' 

::	rcp.center=x,y	Define the center RCP position at x,y in arcseconds.
			Centering takes place immediately after the parsing
			of RCP data.
			@See: 'rcp'

::	rcp.gains	Use gains from the RCP files. Otherwise gains may 
			come from the 'pixeldata' file, or assume default
			values, such as 'uniform'.
			@See: 'rcp'

::	rcp.rotate=X	Rotate the RCP positions by X degrees (counter 
			clockwise). Rotations take place after centering (if
			specified).
			@See: 'rcp'

::	rcp.zoom=X	Zoom (rescale) the RCP position data by the scaling
			factor X. Rescaling takes place after the centering
			(if defined).	
			@See: 'rcp'

	read <filename>	  Read the scan data from <filename>, which can be 
			  either a fully specified path, or relative to
			  'datapath'. (On the command line it is sufficient
			  to list the filename without a preceding dash.)

	read scanNo	  Read scan number scanNo (scripting only).
			  in command line mode, ommit '-read='.

	read from-to	  Read the range of scan numbers between from and to.
	     		  (inclusive). On the command line, you can omit 
			  '-read=' and simply list the scan range.

	read X Y [...]    You can combine scan numbers and different ranges
			  in a space-spearated list...
			
	read...		  As mentioned, the 'read' keys only apply to scripts.
			  Thus, 

				read 10755-10762             # in script

			  and

				> ./crush [...] 10755-10762  # command line

			  are equvivalent.


	recall=<option>		Undoes 'forget', and reinstates the <option>
				to its old value.	

	remove=<option>		Similar to 'forget', but removes the entire
				branch. Thus '-remove=despike' unsets:

					despike
					despike.level
					despike.method
					despike.flagfraction
					...
	replace=<option>	Undoes the 'remove' option, reinstating the
				<option> tree to its prior state.


	reservecpus=N	Instruct crush NOT to use N number of CPUs of the 
			machine. By default crush will try to use all 
			processors in your machine for maximum performance. 
			This option allows to modify this behavior according 
			to need. Note, that at least 1 CPU will always be used 
			by crush, independent of this setting.
			The number of actual parallel threads will be the 
			smaller of the allowed number of CPUs and the number 
			of scans processed.


	resolution

	response

	response.calc

	rot0

	rotation


	rounds=N	Iterate N times. You may want to increase the number
			of default iterations either to recover more extended
			emission (e.g. when 'extended' is set), or to go
			deeper (esp. when the 'faint' or 'deep' options are
			used).

	rows		decorrelate.rows

	scale=X		  Scale the fluxes by X. With this option you can apply
			  calibration corrections to your data.

	scale=<filename>  Alternatively, scan specific scaling can be defined
			  by an appropriate calibration file, which among 
			  other things, contains the ISO time-stamp and	
			  the corresponding calibration values for each scan.
			  The filename may contain references to environment
			  variables enclosed in {} brackets. E.g.:

			    scale={$HOME]}/laboca/scaling.dat


	scanmaps	When specified, a map will be written for each scan
			(every time it is solved), under the name 
			'scan-<scannumber>.fits' in the usual output path.
			Best to use as:
			     
			     iteration:last scanmaps
 			
			to avoid the unnecessary writing of scan maps for every
			iteration (unless you really want that to be the case).


	scramble	Make a map with inverted scanning offsets. Under the
			typical scanning patterns, this will not produce a
			coherent source. Therefore it is a good method for
			checking on the noise properties of deep maps.

	scramble	  Another technique for generating noise maps, which 
			  can be used also for small datasets, for which
			  jackknifing cannot be used. This approach scrambles
			  the pixel positions, such that the source signals
			  will be smeared out in the maps.


	serial.[...]

	signal-response

	skydip		Reduce skydip data, instead of trying to make an 
			impossibly large map out of it :-). This option is
			equivalent to specifying 'source.type=skydip'.

	skydip.grid?

	skydip.fit

	skydip.Kelvin

	skydip.offset

	skydip.tau

	skydip.Tsky

	smooth=X	Smooth the map by X arcsec FWHM beam. Smoothing
			helps improve visual appearance, but is also useful
			during reduction to create more redundancy in the data
			in the intermediate reduction steps. Also, smoothing
			by the beam is optimal for point source extaction from
			deep fields. Therefore, beam smoothing is default in
			with the 'deep' option (see 'deep.cfg').
			Typically you want to use some smoothing during 
			reduction, and you may want to turn it off in the 
			final map. Thus, you may have something like:

			  smooth=9.0			# 9" smoothing at first
			  iteration.[2]smooth=12.0 	# smooth more later
			  iteration.[last]forget=smooth # no smoothing at last

			Other than specifying explicit values, you can use
			the predefined values: 'minimal', 'halfbeam', '2/3beam'
			or 'beam'. See more on smoothing in the advanced
			configuration section.


	smooth.external

	smooth.optimal

	source		Solve for the source model.
			The optional argument [opt] can be:

				nosync		Do not sync the derived source
						increment to the data.
						Use only if you're sure you
						want this...
				mem		Maximum-Entropy correction. 

			MEM mapping can be used to suppress low-level noise
			but may cause some filtering on faint structures
			also. Nonetheless, it is an attractive method to
			produce very clean looking maps when for sources with
			S/N >> 1.


	source.correct

	source.coupling

	source.coupling.range

	source.despike  Despike scan maps at the significance level X. 
			  Clearly you want to set X to be higher than the most 
			significant source in your map. Therefore it is only 
			really useful in 'deep' mode, where 5-sigma despiking
			is default (see 'deep.cfg').


	source.despike.level

	source.filter   Filter extended structures. By default the filter will
			skip over map pixels that are above the 'blanking' S/N 
			level (>6 by default). Thus any structure above this 
			significance level will remain unfiltered.
			Filtering is useful to get deeper in the map when 
			retaining the very faint extended structures is not 
			an issue. Thus filtering above 5 times the source size
			(see 'sourcesize') is default when the filter is used.
			See the advanced configuration section for further
			details on fine tuning the large-scale structure 
			filter.	

	source.filter.blank

	source.filter.fwhm

	source.filter.type

	source.fixedgains	Specifies to use the fixed source gains 
			        (e.g. from an RCP file -- see 'rcp' key).
			Normally, crush calculates source gains based on the 
			correlated noise response and the specified point
			source couplings (e.g. as derived from the two gain
			columns of RCP files.)



	source.intermediates  Write the maps made during the reduction into 
			  'intermediate.fits' (inside the minicrush directory).
			This option thus allows to keep an eye on the evolution
			of maps iteration-to-iteration. Each iteration will
			overwrite this 'temporary' file, and it will be erased
			at the end of the reduction.

	source.mem

	source.mem.lambda

	source.model=<file>  Specify a in initial source model tgo use in the
			    reduction. The option is useful to feed back the
			result from a previous reduction into another reduction
			round. This may be useful when reducing large datasets
			where all data cannot be reduced together. Instead the
			data can be split in manageable sized chunks, which are
			reduced separately. The results can be coadded with the
			'coadd' utility to create a composite map. This may
			be further manipulated (e.g. s/n clipping, smoothing,
			filtering etc.) with 'imagetool' before feeding back
			into another round of reduction.



	source.nefd=min:max	Specify a range of acceptable NEFDs in 
				Jy sqrt(s) units. All scans with NEFD outside
				this range will not contribute to the composite
				map.
				If the optional 'min' value is not given, then
				it is assumed as 0. ('-' may also be used in
				place of ',' for separating min and max 
				values.) 

	source.nosync

	source.polarization

	source.redundancy=N  Specify the minimum redundancy (N samples) that
			      each scan-map pixel ought to have in order to be
			considered valid. Pixels with redundancies smaller than
			this critical value will be flagged an not used in
			the composite source mapmaking.

	source.synchronized

	source.type=<type>	By default, crush will try to make a map from
				the data. However, some istruments may take
			data that is analyzed differently. For example, you 
			may want to use crush to reduce beam maps (to
			determine the positions of your pixels on sky), or
			skydips (to derive appropriate opacities), or do
			point source photometry. Presently, the following
			source types are supported accross the board:
		
			   map 		Make a map of the source (default)

			   skydip	Reduced skydips, and determine 
					opacities by fitting a model to it.

			   beammap	Create individual maps for every
					pixel, and use it to determine their
					location in the field of view.
			
			Note, that you may also just use 'skydip' and 'beammap'
			shorthands to the same effect. E.g.

			  > crush [...] -skydip [...]

	sourcesize=X	This option can be used instead of 'extended' in 
			conjunction with 'faint' or 'deep' to specify the 
			typical size of sources (FWHM in arcsec) that are 
			expected. The reduction then allows filtering 
			structures that are much larger than the specified 
			source-size...
			If 'sourcesize' or 'extended' is not specified, then 
			point-like compact sources are assumed.	


	?sourceweights	If specified, appropriate weigths will be calculated
			separately for mapping. Otherwise the usual rms weights
			are used. The difference is that proper source weights
			account for just how much sources of 'sourcesize' are
			filtered as a result of the various decorrelating and
			noise whitening steps.

	split

	squids		correlated.squids

	stability=X		Specify the instrument's 1/f stability time
				scale in seconds. This value is used for 
				optimizing reduction parameters when (e.g. the
				filtering time scale for the 'drifts' option)
				when these are not explicitly specified.

	stability=X	Specify the instrument 1/f stability time-scale in
			seconds. This is used for determining optimal 1/f
			filtering of the time-streams in the reduction.

	supergalactic	system=supergalactic

	system=<type>	Select the coordinate system for mapping. The default
			is 'equatorial'. Other possibilities are 'horizontal'
			'ecliptic', 'galactic' or 'supergalactic'. Each of 
			these values is additionally aliased to simple keys. 
			Thus, you may use:
			
			   > crush -galactic [...]
			   
			as a shorthand for '-system=galactic'.
			       

	tau=X		  Specify a zenith tau value to use. When not used
			  minicrush will try to interpolate from
			  <instrument>/<instrument>-taus.master.dat if possible
			  or use 0.0 as default.

	tau=<filename>	  Alternatively, tau can also specify a file-name with 
			  lookup information (usually containing tau
			  values from the radiometer or from the skydips).
			  Tau values will be interpolated for each scan,
			  as long as the scan falls inside the interpolator's
			  range. Otherwise, tau of 0.0 will be used. The 
			  filename may contain references to environmnent 
			  variables enclosed in {} brackets. E.g.:

			    tau={$HOME}/laboca/tau.dat


	tau.<?>		  [SHARC-2]

	tau.<?>.a

	tau.<?>.b

	time-weighting[=dT]	In addition to pixel weighting, time-weights
				can also be calculated to allow for 
				non-stationary noise. Without an argument
				all exposures are indepently weighted. 
				Otherwise, weight are derived for blocks of
				exposures spanning dT seconds. The value
				'auto' matches the time-constant to that of
				'drifts'.	

	time-weighting.noiserange

	twisting	correlated.twisting	

	uniform		Specify to use uniform pixel gains initially
			instead of the values read from the appropriate
			pixel data file (see 'pixeldata' key)...

	unit=xxx	Set the output to units xxx. You can use either the
			instrumental units (e.g. 'V/beam' or 'counts/beam') or
			the more typical 'Jy/beam' (default), as well as their
			common multiples (e.g. 'uJy/beam', or 'nV/beam').	



	vclip=min[,max]	Clip data where the field scan velocity is outside
			the specified range (in arcsec/sec). The successfull
		 	disentangling of the source structures from the various
			noise terms relies on these being separated in 
			frequency space. With the typical 1/f type limiting 
			noise, this is harder when the scan speed is low s.t. 
			the source signals occupy the low frequencies. 
			Therefore, requiring a minimum scanning speed is a 
			good idea...
			On the other side, too high scanning speeds will smear
			out sources, if the movement between samples is larger
			than ~1/3 beam.


	wafers		correlated.wafers

	waveplate.channel
	
	waveplate.data

	waveplate.fchannel

	waveplate.frequency

	waveplate.jitter

	waveplate.refangle


	weighting	Derive pixel weights based on the rms of the unmodelled
			timestream signals.


	weighting.method	Enable pixel weighting by measured noise. 
				The optional <method> can specify which way
				noise estimates are derived. The following
				methods are available:

				  rms	         Standard rms calculation.
				  robust         Use robust estimates for the
					         standard deviation.
				  differential   Estimate noise based on pairs
					         of data separated by some
						 interval in time.

	weighting.noiserange=	Specify what range of pixel noises are 
		min:max		admissible, relative to the median pixel
				noise. Pixels that fall outside of the
				specified range (min, max) will be flagged.


	weighting.scans  	'robust' or 'maximum-likelihood'.
				If specified, each scan gets an assigned weight
				with which it contributes to the composite map.
				This weight is measured directly from the noise
				properties of the produced map. Note, that this
				option conflicts the the 'extended' option, and
				is ignored when both are specified.

	weighting.scans.method

	whitelist=<option>...	Remove <option> from the blacklist, allowing
				it to be set again if desired. Whitelisting
				an option will not reinstate it to its prior
				value. After whitelisting, you must explicitly
				set it again, or 'recall' or 'replace' it
				to its prior state.


	whiten			Use noise whitening algorithm. Careful, it is
				not yet well tested, and may affect the 
				calibration!!!

	whiten.level

	wiring=<filename>	This option is commonly used to specify a
				file containing the wiring information of
			the detectors, which can be used to establish the
			typical pixel groupings of instruments. There is no
			standard format for the wiring file (it may be
			different for each instrument), and not all instrument
			may use such information. However, those that do have
			this type of data do use the 'wiring' key to point
			to the location of the information.


	write.ascii
			
	write.covar=		Write covariance data. The full pixel-to-pixel 
			covariance data is written, as well as versions of it 
			with pixels reordered in groups (boxes, cables, boards,
			squidgroups or squids) with the dead pixels discarded, 
			for convenient study of the correlated signals that 
			may be present.



	write.pixeldata	Write the pixel data file (gains, weights, flags). The
			putput will be 'pixel-<scanno>.dat'. You can use these
			files to update instrumental defaults in the instrument
			subdirectory. E.g., you can overwrite 

				laboca/laboca-pixel.dat

			to change what default pixel settings to use.


	write.signals

	write.spectrum [name][,][size]  Writes channel spectra (of residuals) in an 
				  ascii table. Optional arguments include the
			'name' of the window function to use (default is 
			'Hamming', and the window size (in powers of 2!, 
			default is 512). 




###############################################################################




			


2. Advanced Source Configuration
================================






	sources=<file>	Add sources as specified by a crush-style mask <file>.
			This is useful for runnign reduction on simulated data
			that can help understanding the systematics of the
			reduction. One thing to look out for is that the
			peaks here have to be specified in the instrument's 
			native units (i.e. volts), rather than Jy. This way
			any conversion related confusion is bypassed since the
			signal levels are unambigiously specified.


3. Advanced Scan Configuration
==============================




	shift=X		Shift positional information by X seconds. This is 
			meant to be used only when there is a timing problem, 
			whereby the data frames are misaligned from the 
			telescope position data.
	
	taufactor=X	One can specify a factor by which skydip-equivalent 
			tau values ought to be multiplied to obtain good 
			calibration. A gain dependece on loading can be 
			effectively modeled in this way. E.g. for LABOCA
			taufactor=1.3 provides approximately flat calibration
			in all weather conditions and at all elevations.

	scanmap-redundancy=N   Specify the minimum number of data points that
			       have to contribute to each pixel in a scan's
			       map in order for that pixel to be valid.






4. Pipeline elements (Models) and their options
===============================================



			
	
	sky			Model spacial sky noise as gradients accross
				the array.

	
	neighbours		Decorrelate pixel neighbours on array. Note,
				this is effectively an extended structure 
				filter which gets more aggressive with 
				iterations. Therefore use only with care, if
				you must, and for 1 or few iterations only!!!





4.5. Further output options
===========================









   





2.1. Commands
=============

There are a handful of keywords that are treated as commands by crush. (The
difference being that commands are interpreted and acted on right away, whereas 
typical configuration keys are stored settings that are interpreted later as 
necessary.) The commands are:
   

   	config=<filename>	Load the configuration file filename. 
				The file is looked for in the locations in the
				following order:

					1. ./
					
					2. ./<instrument>/

					3. ~/.crush2/

					4. ~/.crush2/<instrument>/

				Whenever a matching file is found its contents
				are parsed. Because of the ordering, it is 
				convenient to create overriding configurations.
				Thus instrument specific settings can be used 
				to override default settings, and user specific
				settings placed in '~/.crush2' can override
				shipped defaults. Whenever a configuration is
				parsed, there is a note of it on the console
				output so that one always knows which files 
				were read and in what order.
				E.g. when using
				
				   > crush laboca -faint 12066

				the following configuration files will be
				loaded in order (provided they exist):

				   default.cfg
				   laboca/default.cfg
				   ~/.crush2/default.cfg
				   ~/.crush2/laboca/default.cfg
				  
				   faint.cfg
				   laboca/faint.cfg
				   ~/.crush2/faint.cfg
				   ~/.crush2/laboca/faint.cfg
				   
				Each successively loaded file may override
				the options set before it.


	forget=<option>...	Forget the priorly set values for <option>
				as if it were never defined. E.g. 
		     		
					forget=outpath

				will unset the 'outpath' option.
				You can specify more than one options as a
				comma-separated list. E.g.
	
					forget=outpath,project
				
				With unset both the 'outpath' and 'project' 
				options.	

	recall=<option>		Undoes 'forget', and reinstates the <option>
				to its old value.	

	remove=<option>		Similar to 'forget', but removes the entire
				branch. Thus '-remove=despike' unsets:

					despike
					despike.level
					despike.method
					despike.flagfraction
					...

	replace=<option>	Undoes the 'remove' option, reinstating the
				<option> tree to its prior state.

	blacklist=<option>...	Similar to 'forget', except it will not
				set options even if they are then specified
				at a later time. This is useful for altogether
				removing settings from the configuration.

	whitelist=<option>...	Remove <option> from the blacklist, allowing
				it to be set again if desired. Whitelisting
				an option will not reinstate it to its prior
				value. After whitelisting, you must explicitly
				set it again, or 'recall' or 'replace' it
				to its prior state.

	poll			Whenever unsure what options are set at any
	poll=<option>		given stage, you can poll the settings.
				Without an additional argument it will list
				all options to the standard output. When
				an argument is specified it will list
				all configuration settings that start with
				the specified string. E.g.

					> crush [...] -poll=iter
	
				will list all iteration based options that 
				are set including all the [...] options set
				prior to '-poll' in the command line.







				






