| casacore::Aberration | Aberration class and calculations |
| casacore::AbortError | Exception which halts execution |
| casa::AboutDialog | Displays information about Feather to the user |
| casa::AboutDialogViewer | Displays information to the user about the viewer |
| casacore::Abs< T, RES > | Functor to apply abs |
| casacore::AbstractAllocator< T > | |
| casacore::ACG | Additive number generator |
| casa::ACoh | |
| casacore::Acos< T, RES > | Functor to apply acos |
| casa::ActionAnnotate | |
| casa::ActionAnnotateRectangle | |
| casa::ActionAnnotateText | |
| casa::ActionCache | |
| casa::ActionCacheLoad | |
| casa::ActionCacheRelease | |
| casa::ActionClearPlotter | |
| casa::ActionClearRegions | |
| casa::ActionExport | |
| casa::ActionExportDialog | Exports the plots based on the information entered in the export dialog |
| casa::ActionFactory | |
| casa::ActionHoldReleaseDrawing | |
| casa::ActionInformation | |
| casa::ActionIterFirst | |
| casa::ActionIterLast | |
| casa::ActionIterNext | |
| casa::ActionIterPrev | |
| casa::ActionLocate | |
| casa::ActionMarkRegions | |
| casa::ActionPan | |
| casa::ActionPlot | |
| casa::ActionQuit | |
| casa::ActionSelect | |
| casa::ActionSelectFlag | |
| casa::ActionSelectUnflag | |
| casa::ActionStack | |
| casa::ActionStackBack | |
| casa::ActionStackBase | |
| casa::ActionStackForward | |
| casa::ActionSubtractRegions | |
| casa::ActionSummary | |
| casa::ActionSummaryDialog | Displays a dialog allowing the user to specify the data that they want summarized |
| casa::ActionTool | |
| casa::ActionTracker | |
| casa::ActionTrackerDisplay | |
| casa::ActionTrackerHover | |
| casa::ActionZoom | |
| casa::ActiveCaching2dDD | Class providing active behaviour for 2d CachingDisplayDatas |
| casa::AddMuellerDiag | Full polarization "additive Mueller" |
| casa::AddMuellerDiag2 | Parallel-hands only "additive Mueller" |
| casa::dbus::address | |
| casa::AgentFlagger | AgentFlagger: high-performance automated flagging |
| casacore::AipsError | Base class for all Casacore library errors |
| casa::utilj::AipsErrorTrace | |
| casacore::AipsIO | AipsIO is the object persistency mechanism of Casacore |
| casacore::AipsIOCarray_global_functions_AipsIOCarray | Templated functions to get/put a C-style array from/into AipsIO |
| casacore::AipsIOReaderWriter | Implementation of CASA region AipsIO file reader and writer |
| casacore::Aipsrc | Class to read the casa general resource files |
| casacore::AipsrcValue< T > | Class to read values from the Aipsrc general resource files |
| casacore::AipsrcValue_Bool< Bool > | Specialization of AipsrcValue for Bool |
| casacore::AipsrcVector< T > | Read multiple values from the Aipsrc resource files |
| casacore::AipsrcVector_Bool< Bool > | Specialization of AipsrcVector for Bool |
| casacore::AipsrcVector_String< String > | Specialization of AipsrcVector for String |
| casacore::LatticeStatistics< T >::AlgConf | |
| casa::Algorithm | Defines a computational unit for parallel processing |
| casacore::AlignedAllocator< T, ALIGNMENT > | An allocator which allocates aligned memory |
| casacore::AlignMemory | Referenced counted pointer for constant data |
| casacore::AllFunc< T > | Define logical Functors |
| casacore::Allocator_private | |
| casacore::AllocError | Allocation errors |
| casacore::Allocator_private::AllocSpec< T > | Allocator specifier |
| casacore::AllocSpec< T > | Allocator specifier |
| casa::ALMAAperture | Class ALMAAperture : public ATerm |
| casa::ALMACalcIlluminationConvFunc | |
| asdm::AlmaRadiometerRow | Row of a AlmaRadiometerTable |
| asdm::AlmaRadiometerTable | Alma table |
| alone_display_applications | Definitions of functions needed for stand-alone display applications |
| casa::AMueller | |
| asdm::Angle | Implements a quantity of angle in radians |
| asdm::AngularRate | Implements a quantity of AngularRate in radians per second |
| casa::Animator | Animation controller for WorldCanvasHolders |
| casa::AnimatorHolder | Manages the Animator display on the viewer that allows users to scroll through either the channels withen an image or between loaded images |
| casa::AnimatorRefEH | WorldCanvas refresh event handler for Animator class |
| casa::AnimatorWidget | Manages an individual panel of the viewer animator |
| casa::AniPosEH | WorldCanvas position event handler for Animator |
| casa::AnnAnnulus | This class represents an annotation for an annular (in position coordinates) region specified in an ascii region file as proposed in CAS-2285. It is specified by its center position and inner and outer radii. <author>Dave Mehringer</author> |
| casa::AnnCenterBox | This class represents a annotation for rectangular (in position coordinates) region specified in an ascii region file as proposed in CAS-2285. It is specified by its center position and side widths. <author>Dave Mehringer</author> |
| casa::AnnCircle | This class represents an annotation for a circular (in position coordinates) region specified in an ascii region file as proposed in CAS-2285. It is specified by its center position and radius. <author>Dave Mehringer</author> |
| casa::AnnEllipse | This class represents an annotation of an elliptical (in position coordinates) region specified in an ascii region file as proposed in CAS-2285. It is specified by its center position semi-major and semi-minor axes, and position angle. <author>Dave Mehringer</author> |
| casa::AnnLine | Represents a line annotation |
| casa::Annotation | |
| casa::AnnotationBase | Base class for annotations |
| casa::AnnotationEditor | |
| casa::AnnotationEditorText | |
| asdm::AnnotationRow | Row of a AnnotationTable |
| casa::Annotations | Control class for a collection of DisplayShapeInterfaces |
| asdm::AnnotationTable | Alma table |
| casa::AnnotationText | |
| casa::AnnPolygon | This class represents a single polygon (in position coordinates) annotation specified in an ascii region file as proposed in CAS-2285 <author>Dave Mehringer</author> |
| casa::AnnPolyline | This class represents a single polyline (in position coordinates) annotation specified in an ascii region file as proposed in CAS-2285 |
| casa::AnnRectBox | This class represents an annotation for rectangular (in position coordinates) region specified in an ascii region file as proposed in CAS-2285 <author>Dave Mehringer</author> |
| casa::AnnRegion | This class represents a annotation referring to a region specified in an ascii region file as proposed in CAS-2285 <author>Dave Mehringer</author> |
| casa::AnnRotBox | This class represents an annotation for rectangular (in position coordinates) region specified in an ascii region file as proposed in CAS-2285. It is specified by its center position and side widths and a position angle. <author>Dave Mehringer</author> |
| casa::AnnSymbol | Represents a symbol annotation |
| casa::AnnText | Represents a text annotation |
| casa::AnnVector | Represents a vector annotation which has a start and ending point |
| casa::ANoise | Additive noise In practice, this is not really solvable, but it is a SVM because we need access to general simulation methods |
| casa::ANoiseCorruptor | |
| casa::sdfiller::AntennaRecord | |
| casa::AntennaResponses | AntennaResponses provides access to antenna response data |
| asdm::AntennaRow | Row of a AntennaTable |
| asdm::AntennaTable | Alma table |
| casacore::AnyFunc< T > | |
| casa::ApertureCalcParams | |
| casacore::AppInfo | General information for applications |
| casa::Applicator | Class which provides an interface to the parallelization infrastructure |
| casa::AppRC | |
| casa::CalStats::ARG< T > | Statistics ARG nested class (allowed T: CalStats::NONE, CalStatsFitter::FIT, or CalStatsHist::HIST), used as an input to stats<T>() and statsWrap<T>() |
| casa::CalStats::ARG< CalStats::NONE > | ----------------------------------------------------------------------------- End of CalStats class definition ----------------------------------------------------------------------------- |
| casa::CalStats::ARG< CalStatsFitter::FIT > | Specialization for the CalStatsFitter::FIT() class |
| casa::functor::args | |
| casa::functor::args01< T1 > | |
| casa::functor::args02< T1, T2 > | |
| casa::functor::args03< T1, T2, T3 > | |
| casa::functor::args04< T1, T2, T3, T4 > | |
| casacore::Array< T > | Template <class T, class U> class vector; |
| casacore::ArrayAccessor< T, Axis< U > > | Fast 1D accessor/iterator for nD array classes |
| casacore::ArrayAccessor_RT< T, AxisN > | Specialization for run-time axes |
| casacore::ArrayBase | Non-templated base class for templated Array class |
| casacore::ArrayBaseAccessor< T > | Axis independent base for the ArrayAccessor classes |
| casacore::ArrayColumn< T > | Read and write access to an array table column with arbitrary data type |
| casacore::ArrayColumnData< T > | Access to a table column containing arrays |
| casacore::ArrayColumnDesc< T > | Templated class for description of table array columns |
| casacore::ArrayConformanceError | An error thrown when two arrays do not conform |
| casacore::ArrayError | The base class for all Array exception classes |
| casacore::ArrayFITSFieldCopier< recordType, fitsType > | A FITSFieldCopier for copying Array RecordFields to FitsFields |
| casacore::ArrayFunctorBase< T, RES > | Basic class for math on Array objects |
| casacore::ArrayIndexError | An error thrown when an index is out of range |
| casacore::ArrayInitPolicy | A global enum used by some Array/Block constructors |
| casacore::ArrayIO_global_functions_Array_Ascii_IO | Global functions for Matrix/Vector input/output using ASCII format |
| casacore::ArrayIO_global_functions_Array_binary_IO | Global functions to read/write binary arrays from/to a file |
| casacore::ArrayIO_global_functions_Array_IO | Input/output operators for Arrays |
| casacore::ArrayIterator< T > | Iterate an Array cursor through another Array |
| casacore::ArrayIteratorError | An error thrown by an ArrayIterator |
| casacore::ArrayKey | An ArrayKey is a unique combination of observation ID and array ID Negative values are allowed to indicate all values of the particular ID are desired |
| casacore::ArrayLattice< T > | A memory resident Lattice |
| casacore::ArrayLogical_global_functions_Array_logical_operations | Logical operations for Arrays |
| casacore::ArrayMath_global_functions_Array_mathematical_operations | Mathematical operations for Arrays |
| casacore::ArrayMeasColumn< M > | Read only access to table array Measure columns |
| casa::ArrayModel< T > | Models with an internal & external representation as an array |
| casacore::ArrayNDimError | Thrown when two arrays have different dimensionality |
| casacore::ArrayOpsDiffShapes_global_functions_OpsDiff_functions | Operations for 2 Arrays with possibly different shapes |
| UvwCoords::ArrayParam | (Sub-)array parameters constraining order and size of the output vector of 3D UVW coords triplets |
| casacore::ArrayPartMath_global_functions_Array_partial_operations | Mathematical and logical operations for Array parts |
| casacore::ArrayPositionIterator | Iterate an IPosition through the shape of an Array |
| casacore::ArrayQuantColumn< T > | Provides read/write access to Array Quantum columns in Tables |
| casacore::ArraySampledFunctional< T > | Index into an array using the longest axis |
| casacore::ArrayShapeError | An error thrown when two arrays have different shapes |
| casacore::ArraySlicerError | An error thrown by an Slicer member function |
| asdm::ArrayTime | Implements the concept of a point in time, implemented as an Interval of time since 17 November 1858 00:00:00 UTC, the beginning of the modified Julian Day |
| asdm::ArrayTimeInterval | Aggregates an instance of ArrayTime and an instance of Interval |
| casacore::ArrayUtil_global_functions_concatenateArray | Concatenate two Arrays |
| casacore::ArrayUtil_global_functions_partialFuncHelper | Helper function for partialX functions |
| casacore::ArrayUtil_global_functions_reorderArray | Reorder the axes of an array |
| casacore::ArrayUtil_global_functions_reorderArrayHelper | Helper function for function reorderArray |
| casacore::ArrayUtil_global_functions_reverseArray | Reverse the order of one or more axes of an array |
| casacore::ArrayUtil_global_functions_stringToVector | Split a String into its elements |
| casa::AsciiAnnotationFileLine | Represents a line in an ascii region file <author>Dave Mehringer</author> |
| casacore::AsciiTableExtension | (ascii) TABLE extension |
| asdm::ASDM | Container for all tables |
| ASDM2MSFiller | Class ASDM2MSFiller |
| ASDM_ALMARADIOMETER | |
| ASDM_ANNOTATION | |
| ASDM_ANTENNA | |
| ASDM_CALAMPLI | |
| ASDM_CALAPPPHASE | |
| ASDM_CALATMOSPHERE | |
| ASDM_CALBANDPASS | |
| ASDM_CALCURVE | |
| ASDM_CALDATA | |
| ASDM_CALDELAY | |
| ASDM_CALDEVICE | |
| ASDM_CALFLUX | |
| ASDM_CALFOCUS | |
| ASDM_CALFOCUSMODEL | |
| ASDM_CALGAIN | |
| ASDM_CALHOLOGRAPHY | |
| ASDM_CALPHASE | |
| ASDM_CALPOINTING | |
| ASDM_CALPOINTINGMODEL | |
| ASDM_CALPOSITION | |
| ASDM_CALPRIMARYBEAM | |
| ASDM_CALREDUCTION | |
| ASDM_CALSEEING | |
| ASDM_CALWVR | |
| ASDM_CONFIGDESCRIPTION | |
| ASDM_CORRELATORMODE | |
| ASDM_DATADESCRIPTION | |
| ASDM_DELAYMODEL | |
| ASDM_DELAYMODELFIXEDPARAMETERS | |
| ASDM_DELAYMODELVARIABLEPARAMETERS | |
| ASDM_DOPPLER | |
| ASDM_EPHEMERIS | |
| ASDM_EXECBLOCK | |
| ASDM_FEED | |
| ASDM_FIELD | |
| ASDM_FLAG | |
| ASDM_FLAGCMD | |
| ASDM_FOCUS | |
| ASDM_FOCUSMODEL | |
| ASDM_FREQOFFSET | |
| ASDM_GAINTRACKING | |
| ASDM_HISTORY | |
| ASDM_HOLOGRAPHY | |
| ASDM_MAIN | |
| ASDM_OBSERVATION | |
| ASDM_POINTING | |
| ASDM_POINTINGMODEL | |
| ASDM_POLARIZATION | |
| ASDM_PROCESSOR | |
| ASDM_RECEIVER | |
| ASDM_SBSUMMARY | |
| ASDM_SCALE | |
| ASDM_SCAN | |
| ASDM_SEEING | |
| ASDM_SOURCE | |
| ASDM_SPECTRALWINDOW | |
| ASDM_SQUARELAWDETECTOR | |
| ASDM_STATE | |
| ASDM_STATION | |
| ASDM_SUBSCAN | |
| ASDM_SWITCHCYCLE | |
| ASDM_SYSCAL | |
| ASDM_SYSPOWER | |
| ASDM_TABLE_BASE | |
| ASDM_TABLE_SINGLETON< T > | |
| ASDM_TOTALPOWER | |
| ASDM_WEATHER | |
| ASDM_WVMCAL | |
| asdm::ASDMParseOptions | A class to define a collection of options regarding the way to consider an ASDM dataset especially when it's about to be read on disk, parsed and transformed into its representation in memory |
| asdm::ASDMUtils | |
| asdm::ASDMUtilsException | |
| asdm::ASDMValuesParser | |
| asdm::ASDMValuesParserException | A class to represent an exception thrown during the parsing of the representation of a basic type value , scalar or array, in the XML representation of an ASDM table |
| ASDMVerbatimFiller | |
| casacore::Asin< T, RES > | Functor to apply asin |
| casacore::LSQFit::AsReal | |
| casacore::assert_< t > | Utility class for Assert macros |
| casa::ROVisibilityIterator::AsyncEnabler | |
| casa::asyncio::AsynchronousInterface | |
| casa::vi::AsynchronousInterface | |
| casacore::Atan< T, RES > | Functor to apply atan |
| casacore::Atan2< L, R, RES > | Functor to apply atan2 |
| casa::ATCAFiller | |
| casa::ATerm | The base class to represent the Aperture-Term of the Measurement Equation |
| casa::refim::ATerm | The base class to represent the Aperture-Term of the Measurement Equation |
| casa::AtmosCorruptor | |
| casa::Attribute | Arbitrary name-value pairs used in the display classes |
| casa::AttributeBuffer | Buffer for storing Attributes |
| casa::AttributeValue< T > | Type-dependent interface for values of Attributes |
| casa::AttributeValueBase | Base class for values of Attributes used in the display classes |
| casa::AttributeValuePoi< T > | Templated class for storing a pointer to the value of an Attribute |
| casa::AttributeValuePoiTol< T > | Templated class for aliased, tolerant AttributeValues |
| casa::AttributeValueTol< T > | Templated class for storing Attributes which have a tolerance |
| casa::AttValue | Provision of type identification services for Attribute classes |
| asdmbinaries::SDMDataObject::AutoDataBinaryPart | A subclass of binaryPart to describe the autodata |
| casacore::AutoDiff< T > | Class that computes partial derivatives by automatic differentiation |
| casacore::AutoDiffA< T > | Class that computes partial derivatives by automatic differentiation |
| casacore::AutoDiffIO_global_functions_AutoDiff_IO_operations | Implements all IO operators and functions for AutoDiff |
| casacore::AutoDiffMath_global_functions_AutoDiff_mathematical_operations | Implements all mathematical operators and functions for AutoDiff |
| casacore::AutoDiffRep< T > | Representation of an automatic differential class data |
| casacore::AutoDiffX< T > | Class that computes partial derivatives by automatic differentiation |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::AvdevFunc< T > | |
| casa::vi::AveragingOptions | AveragingOptions |
| casa::vi::AveragingParameters | |
| casa::vi::AveragingTvi2 | |
| casa::vi::AveragingVi2Factory | The AveragingVi2Factory is used to initialize a VisibilityIterator2 so that it performs time averaging |
| casa::vi::AveragingVi2LayerFactory | |
| casa::AWConvFunc | ------------------------------------------------------------------------------------------- |
| casa::refim::AWConvFunc | |
| casa::AWConvFunc2 | ------------------------------------------------------------------------------------------- |
| casa::AWConvFuncEPJones | ------------------------------------------------------------------------------------------- |
| casa::refim::AWConvFuncEPJones | ------------------------------------------------------------------------------------------- |
| casa::AWProjectFT | |
| casa::refim::AWProjectFT | |
| casa::AWProjectWBFT | |
| casa::refim::AWProjectWBFT | |
| casa::AWProjectWBFTNew | |
| casa::refim::AWProjectWBFTNew | |
| casa::AWVisResampler | |
| casa::refim::AWVisResampler | |
| casa::CalStats::AXES | AXES nested class |
| casa::AxesDisplayData | Interface and simple implementation of axis labelling |
| casa::AxesDisplayMethod | Class to draw a single set of axis labels for AxesDisplayData |
| casacore::AxesMapping | Info about mapping array axes to another order |
| casacore::AxesSpecifier | Specification of axes to keep or remove |
| casa::AxisListener | Interface implemented by classes wanting to receive notice when a plot property changes |
| casa::AzElAperture | |
| casa::refim::AzElAperture | |
| casacore::AzElColumn | Azimuth/elevation derived from TIME, etc |
| casa::BackgroundThread | Manages a thread to do a background operation and communicates back to its controller with regard to work status |
| casa::VisibilityIteratorWriteImpl::BackWriter | A BackWriter is a functor that will extract a piece of information out of its VisBuffer argument and write it out using a "set" method on the supplied VisibilityIterator |
| casa::vi::VisibilityIteratorImpl2::BackWriter | +========================| | | | Output Related Methods | | | +========================| |
| casa::VisibilityIteratorWriteImpl::BackWriterImpl< Setter, Getter > | A simple BackWriterImpl uses a nullary accessor on a VisBuffer |
| casa::vi::VisibilityIteratorImpl2::BackWriterImpl< Setter, Getter > | A simple BackWriterImpl2 uses a nullary accessor on a VisBuffer |
| casa::VisibilityIteratorWriteImpl::BackWriterImpl2< Setter, Getter > | BackWriterImpl2 is slightly more complicated in that it uses a unary accessor |
| casa::vi::VisibilityIteratorImpl2::BackWriterImpl2< Setter, Getter > | BackWriterImpl2 is slightly more complicated in that it uses a unary accessor |
| casa::BarPlot | Bar plot abstract class |
| Base64 | Base64 encode/decode |
| casacore::BaseAllocator< T, Sub > | |
| asdmbinaries::SDMDataObject::Baseband | SDMDataObject::Baseband:: declarations |
| casacore::BaseColumn | Abstract base class for a table column |
| casacore::BaseColumnDesc | An abstract base class for table column descriptions |
| casacore::BaseCompare | Abstract base class for comparing two objects |
| casacore::Array< T >::BaseIteratorSTL | See the function begin() and end() for a detailed description of the STL iterator capability |
| sdmbin::BaselineMetadata | Class for baseline-based metadata objects, one type of component in SDM data objects |
| sdmbin::BaselinesSet | Definition of the second level (the top level) in the tree hierarchy: include the antenna baseline configuration |
| casa::BaselineTable | |
| casacore::BaseMappedArrayEngine< VirtualType, StoredType > | Templated virtual column engine for a table array of any type |
| casacore::BaseSinkSource | Shared base class for ByteSink and ByteSource |
| casacore::BaseSlicesFunctor< T > | Abstract baseclass for slices functors |
| casacore::BaseTable | Abstract base class for tables |
| casacore::BaseTableIterator | Base class for table iterator |
| casacore::BasicFITS_global_functions_ReadFITS | Read a FITS file from a Casacore array |
| casacore::BasicFITS_global_functions_WriteFITS | Write a FITS file to a Casacore array |
| BDF2AsdmStManIndex | |
| casa::BeamCalc | |
| casa::BeamCalcGeometry | |
| casa::BeamManipulator< T > | |
| casa::BeamSkyJones | Beam-like sky-plane effects for the SkyEquation |
| casa::refim::BeamSkyJones | Beam-like sky-plane effects for the SkyEquation |
| casa::BeamSquint | Encapsulates beam squint (RR and LL beams at different directions) |
| casacore::BFEngineMask | Non-templated Helper class to handle the mask |
| asdm::BinaryAttributeReaderFunctor | A pure virtual class whose derived classes are expected to be functors whose behaviours will be to read the differents types of data stored into an EndianIStream |
| asdmbinaries::SDMDataObject::BinaryPart | SDMDataObject::BinaryPart:: declarations |
| casacore::BinarySearch_global_functions_binarysearch | Binary search a sorted, linear, data structure |
| casacore::BinaryTable | BinaryTable is used to translate a FITS binary table to a Casacore Table |
| casacore::BinaryTableExtension | BINTABLE extension |
| casa::BinCountWidget | |
| casacore::StatisticsUtilities< AccumType >::BinDesc | Description of a regularly spaced bins with the first bin having lower limit of minLimit and having nBins equally spaced bins of width binWidth, so that the upper limit of the last bin is given by minLimit + nBins*binWidth |
| casacore::Binomial | Binomial distribution |
| casa::BinPlotWidget | Display a histogram of intensity vs count |
| casacore::BitAnd< T > | Functor for bitwise and of (integer) values |
| casacore::BitFlagsEngine< StoredType > | Templated virtual column engine to map bit flags to a Bool |
| casacore::BitNegate< T > | Functor for bitwise negate of (integer) values |
| casacore::BitOr< T > | Functor for bitwise or of (integer) values |
| casacore::BitVector | Bit vectors of any size |
| casacore::BitVectorHelper | Helper class for BitVector |
| casacore::BitXor< T > | Functor for bitwise xor of (integer) values |
| casa::BJones | ********************************************************** BJones (freq-dep GJones) |
| casa::BJonesDesc | BJonesDesc: Define the format of BJones cal tables |
| casa::BJonesMBuf | BJonesMBuf: BJones calibration main table buffer |
| casa::BJonesMCol | BJonesMCol: RW BJones cal_main column access |
| casa::BJonesMRec | BJonesMRec: BJones cal_main table record access & creation |
| casa::BJonesPoly | |
| casa::BJonesPolyDesc | BJonesPolyDesc: Define the format of BJonesPoly cal tables |
| casa::BJonesPolyMBuf | BJonesPolyMBuf: BJonesPoly calibration main table buffer |
| casa::BJonesPolyMCol | BJonesPolyMCol: RW BJonesPoly cal_main column access |
| casa::BJonesPolyTable | BJonesPolyTable: BJonesPoly calibration table access/creation |
| casa::BJonesTable | BJonesTable: BJones calibration table access/creation |
| casa::BLIdSet | |
| casacore::Block< T > | Simple 1-D array |
| casacore::Block_internal_IsFundamental< T > | |
| casacore::Block_internal_IsPointer< T > | |
| casacore::Block_internal_IsPointer< T * > | |
| casacore::BlockInput | Fixed-length blocked sequential input base class |
| casacore::BlockIO | ---------------------------------------------------------------------------- |
| casacore::BlockIO_global_functions_BlockIO | IO functions for Block |
| casacore::BlockOutput | Fixed-length blocked sequential output base class |
| casacore::BlockTrace | Simple 1-D array |
| casa::BLParameterParser | |
| casa::BLParameterSet | |
| casa::BLTableParser | |
| asdm::Boolean | A collection of static classes to perform conversions between strings and bool values |
| casacore::BitFlagsEngine< StoredType >::BoolToFlags | Functor to convert Bools to flags using a mask |
| casa::BorderLayout | |
| casacore::BucketBase | Abstract base class for Bucket classes |
| casacore::BucketBuffered | Use buffered file IO for buckets in a part of a file |
| casacore::BucketCache | Cache for buckets in a part of a file |
| casacore::BucketCache_global_functions_BucketCache_CallBack | Define the type of the static read and write function |
| casacore::BucketFile | File object for BucketCache |
| casacore::BucketMapped | Use file mapping for buckets in a part of a file |
| casacore::Allocator_private::BulkAllocator< T2 > | |
| casacore::Allocator_private::BulkAllocatorImpl< Allocator > | |
| casacore::Allocator_private::BulkAllocatorInitializer< Allocator > | |
| asdm::Byte | A collection of static methods to perform conversions between strings and byte values (represented as char) |
| casacore::ByteIO | Abstract base class for IO on a byte stream |
| asdmbinaries::ByteOrder | A class to represent byte order information |
| asdm::ByteOrder | A class to represent byte order information |
| casacore::ByteSink | Class for write-only access to data in a given format |
| casacore::ByteSinkSource | Class for read/write access to data in a given format |
| casacore::ByteSource | Class for read-only access to data in a given format |
| casa::C11Timer | |
| casacore::CAbs< T, RES > | Functor to apply complex function fabs |
| CACAPolarization | A helper class for the enumeration ACAPolarization |
| CAccumMode | A helper class for the enumeration AccumMode |
| casa::VisibilityIteratorReadImpl::Cache | |
| casa::vi::VisibilityIteratorImpl2::Cache | Void convertVisFromStokes (const Matrix<CStokesVector> & visibilityStokes, Cube<Complex> & visCube); |
| casa::ms::CachedArrayBase | |
| casa::ms::CachedColumn< T > | |
| casa::ms::CachedPlane< T > | |
| casa::CacheFactory | |
| casa::CacheThread | |
| casa::CachingDisplayData | Base class for auto-caching DisplayData objects |
| casa::CachingDisplayMethod | Assistance class for auto-caching of DisplayData objects |
| asdm::CalAmpliRow | Row of a CalAmpliTable |
| asdm::CalAmpliTable | Alma table |
| casa::CalAnalysis | ----------------------------------------------------------------------------- Start of CalAnalysis class definition ----------------------------------------------------------------------------- |
| asdm::CalAppPhaseRow | Row of a CalAppPhaseTable |
| asdm::CalAppPhaseTable | Alma table |
| asdm::CalAtmosphereRow | Row of a CalAtmosphereTable |
| asdm::CalAtmosphereTable | Alma table |
| asdm::CalBandpassRow | Row of a CalBandpassTable |
| asdm::CalBandpassTable | Alma table |
| casa::CalBuffer | CalBuffer: Calibration table buffer |
| casa::CalCache | |
| casa::calcAntenna | |
| casa::CalCorruptor | For simulating corruptions |
| asdm::CalCurveRow | Row of a CalCurveTable |
| asdm::CalCurveTable | Alma table |
| asdm::CalDataRow | Row of a CalDataTable |
| asdm::CalDataTable | Alma table |
| asdm::CalDelayRow | Row of a CalDelayTable |
| asdm::CalDelayTable | Alma table |
| casa::CalDescBuffer | CalDescBuffer: Calibration table cal_desc buffer |
| casa::CalDescColumns | CalDescColumns: Read-write cal_desc calibration table column access |
| casa::CalDescColumns2 | CalDescColumns2: Read-write cal_desc calibration table column access |
| casa::CalDescRecord | CalDescRecord: Cal_desc table record access and creation |
| asdm::CalDeviceRow | Row of a CalDeviceTable |
| asdm::CalDeviceTable | Alma table |
| asdm::CalFluxRow | Row of a CalFluxTable |
| asdm::CalFluxTable | Alma table |
| asdm::CalFocusModelRow | Row of a CalFocusModelTable |
| asdm::CalFocusModelTable | Alma table |
| asdm::CalFocusRow | Row of a CalFocusTable |
| asdm::CalFocusTable | Alma table |
| asdm::CalGainRow | Row of a CalGainTable |
| asdm::CalGainTable | Alma table |
| casa::CalHistoryBuffer | CalHistoryBuffer: Calibration table cal_history buffer |
| casa::CalHistoryColumns | CalHistoryColumns: Read-write cal_history calibration table column access |
| casa::CalHistoryRecord | CalHistoryRecord: Cal_ table record access and creation |
| asdm::CalHolographyRow | Row of a CalHolographyTable |
| asdm::CalHolographyTable | Alma table |
| casa::Calibrater | Controls the solution of calibration components (Jones Matrices) |
| casa::vi::CalibratingParameters | |
| casa::vi::CalibratingVi2 | |
| casa::vi::CalibratingVi2Factory | A top level class defining the data handling interface for the CalibratingTvi2 module |
| casa::vi::CalibratingVi2FactoryI | |
| casa::CalInterp | |
| casa::CalInterpolation | CalInterpolation: a class to hold calibration interpolation parameters |
| casa::CalInterpolator | CalInterpolator: a class to interpolate calibration information |
| casa::CalIntpMatch | CalIntpMatch: a class to hold calibration interpolation index maps |
| casa::CalIter | CalIter: Sequential calibration table iterator |
| casa::CalIterBase | CalIterBase: Base class for calibration table iterators |
| CallBack | |
| casa::CalLibraryParse | Class to hold values from cal library file parser |
| casa::CalLibSlice | A class to parse the contents of a single CalLib slice i.e., for one caltable, one setup |
| casa::CalMainBuffer | CalMainBuffer: Calibration main table buffer |
| casa::CalMainColumns | CalMainColumns: Read-write cal_main calibration table column access |
| casa::CalMainColumns2< T > | |
| casa::CalMainRecord | CalMainRecord: Calibration table record access and creation |
| casa::CalMap | A base class for calmaps |
| casa::CalPatchKey | A specialized key class for Calibration patch panel elements |
| asdm::CalPhaseRow | Row of a CalPhaseTable |
| asdm::CalPhaseTable | Alma table |
| asdm::CalPointingModelRow | Row of a CalPointingModelTable |
| asdm::CalPointingModelTable | Alma table |
| asdm::CalPointingRow | Row of a CalPointingTable |
| asdm::CalPointingTable | Alma table |
| asdm::CalPositionRow | Row of a CalPositionTable |
| asdm::CalPositionTable | Alma table |
| asdm::CalPrimaryBeamRow | Row of a CalPrimaryBeamTable |
| asdm::CalPrimaryBeamTable | Alma table |
| asdm::CalReductionRow | Row of a CalReductionTable |
| asdm::CalReductionTable | Alma table |
| asdm::CalSeeingRow | Row of a CalSeeingTable |
| asdm::CalSeeingTable | Alma table |
| casa::CalSet< T > | |
| casa::CalSetMetaInfo | ********************************************************** CalSetMetaInfo |
| casa::CalSolVi2Organizer | |
| casa::vi::CalSolvingVi2 | |
| casa::vi::CalSolvingVi2LayerFactory | |
| casa::vi::CalSolvingVi2LayerFactoryByVE | |
| casa::CalStats | ----------------------------------------------------------------------------- Start of CalStats class definition ----------------------------------------------------------------------------- |
| casa::CalStatsAmp | ----------------------------------------------------------------------------- End of CalStatsReal class definition ----------------------------------------------------------------------------- |
| casa::CalStatsFitter | ----------------------------------------------------------------------------- Start of CalStatsFitter class definition ----------------------------------------------------------------------------- |
| casa::CalStatsPhase | ----------------------------------------------------------------------------- End of CalStatsAmp class definition ----------------------------------------------------------------------------- |
| casa::CalStatsReal | ----------------------------------------------------------------------------- Start of CalStatsReal class definition ----------------------------------------------------------------------------- |
| casa::CalTable | CalTable: Calibration table access and creation |
| casa::CalTable2 | CalTable: Calibration table access and creation |
| casa::CalTableDesc | CalTableDesc: Define the format of calibration tables |
| casa::CalTableDesc2 | CalTableDesc: Define the format of calibration tables |
| casa::CalTableFromAIPS | CalTableFromAIPS: Calibration table creation from AIPS FITS file |
| casa::vi::CalVi2LayerFactory | |
| casa::CalVisBuffer | CalVisBuffer extends VisBuffer to support storage and recall of associated residual and differentiated residual data |
| asdm::CalWVRRow | Row of a CalWVRTable |
| asdm::CalWVRTable | Alma table |
| casacore::CanonicalConversion | LDOUBLE is 8 bytes on SUN, but 16 bytes canonical |
| casacore::CanonicalDataConversion | A class with virtual functions to convert canonical format |
| casacore::CanonicalIO | Class for IO in canonical format |
| CAntennaMake | A helper class for the enumeration AntennaMake |
| CAntennaMotionPattern | A helper class for the enumeration AntennaMotionPattern |
| CAntennaType | A helper class for the enumeration AntennaType |
| casa::CanvasCurve | |
| casa::CanvasHolder | Holds the QtCanvas where the spectral profile is drawn |
| casa::CanvasMode | |
| casa::CanvasModeAnnotation | |
| casa::CanvasModeChannel | |
| casa::CanvasModeContextMenu | |
| casa::CanvasModeFactory | |
| casa::CanvasModeRangeSelection | |
| casa::CanvasModeZoom | |
| casacore::Capitalize | Functor to capitalize a std::string |
| casacore::CArg< T, RES > | Functor to apply complex function arg |
| casacore::casacore_allocator< T, ALIGNMENT > | |
| casa::CasacRegionManager | Image component class |
| casacore::CasaErrorTools | |
| casa::CasaImageBeamSet | Represents a set of restoring beams associated with an image. Implements getCommonBeam() |
| casa::CasaImageOpener | Definition of image types and handlers |
| casacore::Casarc | |
| casacore::CasarcCleanup | |
| casacore::CASATask | Task interface |
| CAssociatedCalNature | A helper class for the enumeration AssociatedCalNature |
| CAssociatedFieldNature | A helper class for the enumeration AssociatedFieldNature |
| CAtmPhaseCorrection | A helper class for the enumeration AtmPhaseCorrection |
| CAxisName | A helper class for the enumeration AxisName |
| CBasebandName | A helper class for the enumeration BasebandName |
| CBaselineReferenceCode | A helper class for the enumeration BaselineReferenceCode |
| CBinaryDataFlags | A helper class for the enumeration BinaryDataFlags |
| CCalCurveType | A helper class for the enumeration CalCurveType |
| CCalDataOrigin | A helper class for the enumeration CalDataOrigin |
| CCalibrationDevice | A helper class for the enumeration CalibrationDevice |
| CCalibrationFunction | A helper class for the enumeration CalibrationFunction |
| CCalibrationMode | A helper class for the enumeration CalibrationMode |
| CCalibrationSet | A helper class for the enumeration CalibrationSet |
| CCalType | A helper class for the enumeration CalType |
| casa::CCList | |
| CCorrelationBit | A helper class for the enumeration CorrelationBit |
| CCorrelationMode | A helper class for the enumeration CorrelationMode |
| CCorrelatorCalibration | A helper class for the enumeration CorrelatorCalibration |
| CCorrelatorName | A helper class for the enumeration CorrelatorName |
| CCorrelatorType | A helper class for the enumeration CorrelatorType |
| CDataContent | A helper class for the enumeration DataContent |
| CDataScale | A helper class for the enumeration DataScale |
| CDetectorBandType | A helper class for the enumeration DetectorBandType |
| CDifferenceType | A helper class for the enumeration DifferenceType |
| CDirectionReferenceCode | A helper class for the enumeration DirectionReferenceCode |
| CDopplerReferenceCode | A helper class for the enumeration DopplerReferenceCode |
| CDopplerTrackingMode | A helper class for the enumeration DopplerTrackingMode |
| casacore::Ceil< T, RES > | Functor to apply ceil |
| casa::CEMemImageSkyModel | Image Sky Model for the Cornwell-Evens maximum entropy algorithm |
| casa::CEMemModel | Implements the Cornwell & Evans MEM Algorithm on Lattices |
| casa::CEMemProgress | Class to monitor progress in MEM deconvolution |
| casa::CExp< T > | Call this inline as f(arg/PI2) |
| casa::CExp3< T > | |
| casa::CFBStruct | |
| casa::refim::CFBStruct | |
| casa::CFBuffer | |
| casa::refim::CFBuffer | |
| casa::CFCache | ---------------------------------------------------------------------- |
| casa::refim::CFCache | ---------------------------------------------------------------------- |
| casa::CFCacheTable | An object to manage the caches of pre-computed convolution functions on the disk and in the memory |
| casa::refim::CFCacheTable | An object to manage the caches of pre-computed convolution functions on the disk and in the memory |
| casa::CFCell | Template <class t>=""> |
| casa::CFCStruct | |
| CFieldCode | A helper class for the enumeration FieldCode |
| CFilterMode | A helper class for the enumeration FilterMode |
| CFluxCalibrationMethod | A helper class for the enumeration FluxCalibrationMethod |
| casa::CFNotCached | |
| CFocusMethod | A helper class for the enumeration FocusMethod |
| CFrequencyReferenceCode | A helper class for the enumeration FrequencyReferenceCode |
| casa::CFStore | |
| casa::refim::CFStore | |
| casa::CFStore2 | |
| casa::refim::CFStore2 | |
| casa::CFTerms | The base class to represent the Aperture-Term of the Measurement Equation |
| casa::refim::CFTerms | The base class to represent the Aperture-Term of the Measurement Equation |
| casa::vi::ChannelAccumulationKernel | |
| casa::vi::ChannelAverageKernel | |
| casa::vi::ChannelAverageTransformEngine< T > | |
| casa::vi::ChannelAverageTVI | |
| casa::vi::ChannelAverageTVIFactory | |
| casa::vi::ChannelAverageTVILayerFactory | |
| casa::channelContribution | |
| casa::channelInfo | Struct definition |
| casa::ChannelRangeWidget | |
| casa::VisibilityIteratorReadImpl::Channels | |
| casa::asyncio::ChannelSelection | |
| casa::vi::ChannelSelection | |
| asdm::Character | A collection of static classes to perform conversions between strings and char values |
| asdm::CharCompAccumulator | Functor class of for a comparison between a "given" character and a characted assumed to be read in a file with a an accumulation of the characters read in the file into a accumulating string |
| asdm::CharComparator | Functor class of for a comparison between a "given" character and a characted assumed to be read from a file |
| casacore::ChauvenetCriterionStatistics< AccumType, DataIterator, MaskIterator, WeightsIterator > | Class to calculate statistics using the so-called Chauvenet criterion |
| casacore::Chebyshev< T > | A function class that defines a Chebyshev polynomial |
| casacore::ChebyshevEnums | Define enums for Chebyshev classes |
| casacore::ChebyshevParam< T > | Parameter handling for Chebyshev polynomial parameters |
| casacore::ChebyshevParamModeImpl< T > | A ChebyshevParam with the get/setMode implementation |
| casacore::ChebyshevParamModeImpl_PS< AutoDiff< T > > | Partial specialization of ChebyshevParamModeImpl for AutoDiff |
| casacore::ChebyshevParamModeImpl_PSA< AutoDiffA< T > > | Partial specialization of ChebyshevParamModeImpl for AutoDiff |
| casacore::Choice | Class to ask a user a choice |
| CHolographyChannelType | A helper class for the enumeration HolographyChannelType |
| CInvalidatingCondition | A helper class for the enumeration InvalidatingCondition |
| casa::CJonesDesc | CJonesDesc: Define the format of CJones cal tables |
| casa::CJonesMBuf | CJonesMBuf: CJones calibration main table buffer |
| casa::CJonesMCol | CJonesMCol: RW CJones cal_main column access |
| casa::CJonesMRec | CJonesMRec: CJones cal_main table record access & creation |
| casa::CJonesTable | CJonesTable: CJones calibration table access and creation |
| casa::ClarkCleanAlgorithm | |
| casa::ClarkCleanImageSkyModel | Clark Image Sky Model: Image Sky Model implementing the Clark Clean algorithm |
| casa::ClarkCleanLatModel | A Class for performing the Clark Clean Algorithm on Arrays |
| casa::ClarkCleanModel | A Class for performing the Clark Clean Algorithm on Arrays |
| casa::ClarkCleanProgress | Abstract base class to monitor progress in lattice operations |
| casacore::ClassicalStatistics< AccumType, DataIterator, MaskIterator, WeightsIterator > | Class to calculate statistics in a "classical" sense, ie using accumulators with no special filtering beyond optional range filtering etc |
| casacore::CleanEnums | Lists the different types of Convolutions that can be done |
| casa::viewer::CleanGui | |
| casa::CleanImageSkyModel | |
| casa::Client | Abstraction for the interface between the client (possibly a GUI) and the model (plot engine) that is performing the work |
| casa::ClientFactory | Creates an appropriate client (script, GUI) for communicating with the plot engine |
| casa::ClientScript | Implementation of Client built for user scripting (non-GUI) user interface |
| casacore::CLInterpolator2D< T > | Abstract base class for interpolator used by CurvedLattice2D |
| casa::RFASelector::ClipInfo | |
| casacore::CLIPNearest2D< T > | Arbitrarily shaped 1-dim lattice crosscut |
| casa::CLPatchPanel | |
| casa::CLPPResult | |
| CNetSideband | A helper class for the enumeration NetSideband |
| casa::CollapseResult | |
| casa::Colorbar | |
| casa::ColorComboDelegate | |
| casa::ColorDelegate | |
| casa::ColorDistribution_global_functions_Color_Distribution_interface::colorDistItem | |
| casa::ColorDistribution_global_functions_Color_Distribution_interface | Global functions for generating color cube dimensions |
| casa::ColoredPlot | An color plot is a scatter plot with differentiated colors for points in different bins |
| casa::ColorHistogram | Displays a histogram that allows the user to set the color scale for an image |
| casa::ColorHistogramScale | Overrides QwtLinearColorMap in order to provide QwtPlot color lookups based on a casa ColormapDefinition |
| casa::WorldCanvas::ColorIndexedImage_ | ColorIndexedImage_ stores the state of a WorldCanvas::drawImage() rendering after the chosen data plane has been resampled to screen (Pixelcanvas) pixels and scaled to indices within a fixed-size Colormap, but prior to mapping to actual colors for display |
| casa::Colormap | Describes a method of generating a table of colors |
| casa::QtDisplayPanel::panel_state::colormap_state | |
| casa::ColormapDefinition | |
| casa::ColormapInfo | ColormapInfo stores information about the dynamic mapping of a Colormap |
| casa::ColormapManager | Class to manage registration of colormaps on PixelCanvasColorTables |
| casa::ColorPreferences | Allows user specification of the colors used in drawing the histogram and pluggable functionality |
| casa::ColorProvider | Interface class for decoupling of a parent from a child |
| casa::ColorSummaryDelegate | |
| casa::ColorSummaryWidget | |
| casa::ColorTransferWidget | |
| casacore::ColumnCache | A caching object for a table column |
| casacore::ColumnDesc | Envelope class for the description of a table column |
| casacore::ColumnDescSet | Set of table column descriptions |
| casa::VisibilityIteratorReadImpl::Columns | |
| casa::VisibilityIteratorWriteImpl::Columns | |
| casacore::ColumnSet | Class to manage a set of table columns |
| casacore::ColumnsIndex | Index to one or more columns in a table |
| casacore::ColumnsIndexArray | Index to an array column in a table |
| casacore::ColumnSlicer | |
| casacore::CombiFunction< T > | Form a linear combination of function objects |
| casacore::CombiFunction_PS< AutoDiff< T > > | Partial specialization of CombiFunction for AutoDiff |
| casacore::Combinatorics | Combinatorics related functions |
| casacore::CombiParam< T > | Parameters for a linear combination of function objects |
| casacore::Compare_global_functions_ObjCompareFunc | Signature of comparison functions |
| casacore::CompareIntervalInt< T > | Integer comparison class with intervals |
| casacore::CompareIntervalReal< T > | Real comparison class with intervals |
| casacore::CompareNoCase | Case-insensitive string comparison class |
| casacore::CompiledFunction< T > | Form a linear combination of function objects |
| casacore::CompiledParam< T > | Parameters for a compiled string function object |
| casa::CompiledSpectralElement | Describes a compiled function for describing a spectral profile |
| casacore::LSQFit::Complex | |
| asdm::Complex | Extends the Complex class in the C++ standard library |
| casacore::Complex_global_functions_Complex_desc | Single and double precision complex numbers |
| Complexfwd_global_functions_Complexfwd | Forward declaration complex classes |
| casa::ComplexImageRegridder | |
| casa::ComponentFTMachine | |
| casa::refim::ComponentFTMachine | ComponentFTMachine: a abstract base class defining the interface for a Fourier Transform Machine to be used in the SkyEquation for the transformation of SkyComponents |
| casa::ComponentImager | |
| casa::ComponentList | A class for manipulating groups of components |
| casa::ComponentListDeconvolver< T > | |
| casa::ComponentListWrapper | Provides convenient accessors and functionality for a ComponentList |
| casa::ComponentShape | Base class for component shapes |
| casa::ComponentType | Enumerators common to the ComponentsModels module |
| casa::utilj::ComposedFunctor< F, G > | Prints out 104 116 136 |
| casacore::CompositeNumber | This class generates composite numbers |
| casacore::CompoundFunction< T > | Sum of a collection of Functions which behaves as one Function object |
| casacore::CompoundFunction_PS< AutoDiff< T > > | Partial AutoDiff specialization of CompoundFunction |
| casacore::CompoundParam< T > | Parameters for sum of parameterized Functions |
| casacore::CompressComplex | Virtual column engine to scale a table Complex array |
| casacore::CompressComplexSD | Virtual column engine to scale a table Complex array for Single Dish data |
| casacore::CompressFloat | Virtual column engine to scale a table float array |
| casacore::ConcatColumn | A column in a concatenated table |
| casacore::ConcatRows | Class holding the row numbers in a ConcatTable |
| casacore::ConcatRowsIter | Class to iterate through a ConcatRows object |
| casacore::ConcatScalarColumn< T > | A typed column in a concatenated table |
| casacore::ConcatTable | Class to view a concatenation of tables as a single table |
| casa::async::Condition | |
| asdm::ConfigDescriptionRow | Row of a ConfigDescriptionTable |
| asdm::ConfigDescriptionTable | Alma table |
| casacore::Conj< T, RES > | Functor to apply complex function conj |
| casacore::LSQFit::Conjugate | |
| casacore::ConstantND< T > | A constant function |
| casacore::ConstantND_PS< AutoDiff< T > > | Partial specialization of ConstantND for AutoDiff |
| casacore::ConstantNDParam< T > | Parameter handling for a constant function in a space of arbitrary dimensionality |
| casa::ConstantSpectrum | Model the spectral variation with a constant |
| casacore::ConstFitsKeywordList | List of read-only FITS keywords |
| casacore::ConstHashMapIter< key, val > | |
| casacore::Array< T >::ConstIteratorSTL | |
| casacore::ConstListIter< t > | Doubly linked constant list iterator |
| casacore::ConstMapIter< key, value > | Const associative array iterator |
| ConstMirPolSetup | Static container for a set of Miriad polarization correlation types |
| casacore::ConstrainedRangeStatistics< AccumType, DataIterator, MaskIterator, WeightsIterator > | Abstract base class for statistics algorithms which are characterized by a range of good values |
| casa::ContinuumPartitionMixin< T > | Parameter and input data partitioning for parallel continuum imaging (in ParallelImagerMixin) |
| casa::ControlRecord | |
| casacore::ConvEnums | Lists the different types of Convolutions that can be done |
| casacore::Conversion | A class with general conversion definitions |
| asdm::ConversionException | Exception when an error occurs in converting a table to its external representation or in restoring a table from one of its external representations |
| casacore::ConversionIO | Class for IO in a converted format |
| casa::Converter | |
| casa::ConverterChannel | Purpose of this class is to convert from channels= pixels to the world units/pixels used by the spectral axis |
| casa::ConverterFrequency | |
| casa::ConverterFrequencyVelocity | |
| casa::ConverterFrequencyWavelength | |
| casa::ConverterIntensity | Converts intensity units: Jy/Beam, Kelvin, Fraction of Peak, etc |
| casa::ConverterVelocity | |
| casa::ConverterVelocityFrequency | |
| casa::ConverterVelocityWavelength | |
| casa::ConverterWavelength | |
| casa::ConverterWavelengthFrequency | |
| casa::ConverterWavelengthVelocity | |
| casacore::ConvertScalar_global_functions_Scalar_conversion | Templated functions to convert scalars from one type to another |
| casa::ConvFuncDiskCache | An object to manage the caches of pre-computed convolution functions on the disk and in the memory |
| casa::vi::ConvolutionDataKernel | |
| casa::ConvolutionEquation | Implements the convolution equation |
| casa::ConvolutionFunction | The base class to compute convolution functions for convolutional gridding |
| casa::refim::ConvolutionFunction | The base class to compute convolution functions for convolutional gridding |
| casa::vi::ConvolutionKernel | |
| casa::vi::ConvolutionLogicalORKernel | |
| casa::vi::ConvolutionTransformEngine< T > | |
| casa::vi::ConvolutionTVI | |
| casa::vi::ConvolutionTVIFactory | |
| casa::vi::ConvolutionWeightPropagationKernel | |
| casacore::ConvolveGridder< Domain, Range > | Does convolutional gridding |
| casacore::Convolver< FType > | A class for doing multi-dimensional convolution |
| casacore::Coordinate | Interface for converting between world and pixel coordinates |
| casacore::CoordinateSystem | Interconvert pixel and world coordinates |
| casacore::CoordinateUtil | Functions for creating default CoordinateSystems |
| casacore::Copy_global_functions_copy | Copy methods |
| casacore::Copy_global_functions_test | Test routines |
| casacore::Copy_global_functions_throw | Copy objects from one C-style array to another |
| casacore::CopyRecordToRecord | Copies fields between Records, possibly to fields with another name |
| casacore::CopyRecordToTable | Copies fields from a Record to columns of a Table |
| asdm::CorrelatorModeRow | Row of a CorrelatorModeTable |
| asdm::CorrelatorModeTable | Alma table |
| asdmbinaries::CorrSubsetHeaderParser | Class CorrSubsetHeaderParser |
| casacore::Cos< T, RES > | Functor to apply cos |
| casacore::Cosh< T, RES > | Functor to apply cosh |
| casacore::CountedPtr< t > | Referenced counted pointer for constant data |
| casacore::CountedPtr_global_functions_dereference_error | Act on dereference error |
| casacore::COWPtr< T > | Copy-On-Write-Pointer class - allows control of copy based on constness |
| CPointingMethod | A helper class for the enumeration PointingMethod |
| CPointingModelMode | A helper class for the enumeration PointingModelMode |
| CPolarizationType | A helper class for the enumeration PolarizationType |
| CPositionMethod | A helper class for the enumeration PositionMethod |
| CPositionReferenceCode | A helper class for the enumeration PositionReferenceCode |
| CPrimaryBeamDescription | A helper class for the enumeration PrimaryBeamDescription |
| CPrimitiveDataType | A helper class for the enumeration PrimitiveDataType |
| CProcessorSubType | A helper class for the enumeration ProcessorSubType |
| CProcessorType | A helper class for the enumeration ProcessorType |
| casa::memory::cptr< T > | |
| CRadialVelocityReferenceCode | A helper class for the enumeration RadialVelocityReferenceCode |
| CReceiverBand | A helper class for the enumeration ReceiverBand |
| CReceiverSideband | A helper class for the enumeration ReceiverSideband |
| casa::CrosshairEvent | WorldCanvasEvent:contains info on the WC point selected by MWCCrosshairTool |
| casa::viewer::ds9writer::cs | |
| CSBType | A helper class for the enumeration SBType |
| CScanIntent | A helper class for the enumeration ScanIntent |
| CSchedulerMode | A helper class for the enumeration SchedulerMode |
| casa::CSCleanImageSkyModel | CS Image Sky Model: Image Sky Model implementing the CS Clean algorithm |
| CSidebandProcessingMode | A helper class for the enumeration SidebandProcessingMode |
| CSourceModel | A helper class for the enumeration SourceModel |
| CSpectralResolutionType | A helper class for the enumeration SpectralResolutionType |
| CStationType | A helper class for the enumeration StationType |
| CStokesParameter | A helper class for the enumeration StokesParameter |
| casa::CStokesVector | Two specialized 4-vector classes for polarization handling |
| CSubscanIntent | A helper class for the enumeration SubscanIntent |
| CSwitchingMode | A helper class for the enumeration SwitchingMode |
| CSynthProf | A helper class for the enumeration SynthProf |
| CSyscalMethod | A helper class for the enumeration SyscalMethod |
| casa::CTBuffer | |
| casa::CTCache | |
| casa::CTCalPatchKey | |
| casa::CTColumns | A class to provide easy read-write access to NewCalTable columns |
| casa::CTDesc | CTDesc: Define the format of calibration tables |
| casa::CTEnums | |
| CTimeSampling | A helper class for the enumeration TimeSampling |
| CTimeScale | A helper class for the enumeration TimeScale |
| casa::CTInterface | |
| casa::CTIter | Writable version (limited to certain 'columns') |
| casa::CTMainColInterface | |
| casa::CTMainColumns | |
| casa::CTMainRecord | CTMainRecord: Calibration table record access and creation |
| casa::CTPatchedInterp | |
| casa::CTSelection | CTSelection: Class to represent a selection on a CASA CalTable |
| casa::CTTimeInterp1 | |
| casacore::Cube< T > | A 3-D Specialization of the Array class |
| casa::CubePartitionMixin< T > | Parameter and input data partitioning for parallel cube imaging (in ParallelImagerMixin) |
| casa::CubeSkyEquation | |
| casa::CubeView< T > | We need to have the CubeView definition here because its type is used by FlagDataHandler class |
| casa::LinkedCursorEH::cursor_info_t | |
| casa::CursorLink | |
| casa::CursorTrackingHolder | Dock widget which manages the cursor tracking dialogs |
| casacore::CurvedImage2D< T > | An image crosscut based on a curve in a plane |
| casa::CurveDisplay | Contains display information about a specific curve in the plot such as color, name, and whether it should be shown |
| casacore::CurvedLattice2D< T > | A lattice crosscut based on a curve in a plane |
| CWeightType | A helper class for the enumeration WeightType |
| CWindowFunction | A helper class for the enumeration WindowFunction |
| CWVRMethod | A helper class for the enumeration WVRMethod |
| casa::CalStats::DATA | DATA nested class |
| casacore::MSMIndColumn::Data | |
| casa::QtDBusPlotSvrAdaptor::data_desc | |
| casa::QtDBusViewerAdaptor::data_desc | |
| casa::sdfiller::DataAccumulator | |
| casa::sdfiller::DataAccumulator::DataAccumulatorKey | |
| casa::DatabaseConnector | Maintains a connection to an SQLite database |
| DataBlock | |
| casa::sdfiller::DataChunk | |
| casacore::DataConversion | Abstract base class with functions to convert any format |
| casa::DataCubeHolder< T > | |
| casa::vi::DataCubeHolder | |
| casa::DataCubeHolderBase | |
| casa::vi::DataCubeHolderBase | |
| casa::DataCubeMap | |
| casa::vi::DataCubeMap | |
| DataDescComponents | Pair of indicies identifying the spectral window and polarization ids that make up a data description ID |
| sdmbin::DataDescParams | |
| asdm::DataDescriptionRow | Row of a DataDescriptionTable |
| sdmbin::DataDescriptionsSet | Definition of the first level in the tree hierarchy: set of spectro-polarization descriptions, basebands |
| asdm::DataDescriptionTable | Alma table |
| sdmbin::DataDump | The class DataDump extends the class DataStructure by adding time information to assign to the dump the observation date etc |
| casa::vi::DataFFTKernel | |
| casa::vi::DataInterpolationKernel | |
| casa::DataIteratorMixin< T > | Simple non-transforming (widening excepted) data iterator types |
| DataLoadingBuf | Container for data buffers used to fill a measurement set |
| casacore::DataManager | Abstract base class for a data manager |
| casacore::DataManager_global_functions_DataManagerCtor | Define the type of the static construction function |
| casacore::DataManagerColumn | Abstract base class for a column in a data manager |
| casacore::DataManError | Base error class for table data manager |
| casacore::DataManInfo | Class with static functions to manipulate a datamanager record |
| casacore::DataManInternalError | Internal table data manager error |
| casacore::DataManInvDT | Table DataManager error; invalid data type |
| casacore::DataManInvOper | Table DataManager error; invalid operation |
| casacore::DataManUnknownCtor | Table DataManager error; invalid data manager |
| casacore::DataManUnknownVirtualColumn | Table DataManager error; unknown virtual column |
| casa::sdfiller::DataRecord | |
| casa::DataSampling | Provides sampling of data for esimation algorithms |
| asdmbinaries::SDMDataObject::DataStruct | SDMDataObject::DataStruct:: declarations |
| sdmbin::DataStructure | A class which gathers the attributes required to define data structures |
| casacore::DataType_global_functions_DataType | Data types (primarily) in the table system |
| casa::DBeamSkyJones | Model the polarization leakage in the Sky Jones Matrices |
| casa::DBusService | |
| casa::DBusSession | |
| casa::DBusThreadedBase | |
| casa::DDDEllipse | Implementation of an ellipse/rectangle object for DrawingDisplayData class |
| casa::DDDHandle | A class to draw and detect handles on a DDDObject |
| casa::DDDiffFunc | DDDiffFunc: maps two correlations A and B into func(A)-func(B) |
| casa::DDDObject | Base class describing interface for objects supported by DrawingDisplayData |
| casa::DDDPolygon | Implementation of aan ellipse object for DrawingDisplayData class |
| casa::DDDRectangle | Implementation of a rectangular object for DrawingDisplayData class |
| casa::DDDummy | DDDummy: dummy mapper, throws an excpetion if any methods are called |
| casa::DDFunc | DDFunc: maps correlation A into func(A) |
| casa::DDFuncDiff | DDFuncDiff: maps two correlations A and B into func(A-B) |
| casa::DDFuncSum | DDFuncSum: maps two correlations A and B into func(A+B) |
| casa::DDMapper | Abstract Derived Data Mapper class |
| ddMgr | Class ddMgr is a utility to help for the management of DataDescription, SpectralWindow and Polarization ids |
| casa::DDModEvent | Class used by DisplayDatas to signal change in data |
| casa::DDSumFunc | DDSumFunc: maps two correlations A and B into func(A)+func(B) |
| casa::Deconvolver | A simple deconvolver operating on images (no SkyEquation) |
| casacore::DefaultAllocator< T > | An aligned allocator with the default alignment |
| casacore::DefaultValue_global_functions_defval | A templated function which sets a variable to a default value |
| casa::DefaultWCCoordinateHandler | Class to provide default coordinate handling for WorldCanvases |
| casa::DefaultWCSizeControlHandler | Default WorldCanvas SizeControl handler |
| casa::DelayFFT | |
| asdm::DelayModelFixedParametersRow | Row of a DelayModelFixedParametersTable |
| asdm::DelayModelFixedParametersTable | Alma table |
| asdm::DelayModelRow | Row of a DelayModelTable |
| asdm::DelayModelTable | Alma table |
| asdm::DelayModelVariableParametersRow | Row of a DelayModelVariableParametersTable |
| asdm::DelayModelVariableParametersTable | Alma table |
| casacore::CountedPtr< t >::Deleter< T > | Helper class to make deletion of object optional |
| casa::sdfiller::Deleter | |
| casa::utilj::DeltaThreadTimes | |
| casacore::DerivedMSCal | Virtual column engine to return derived MS values |
| casa::DetailsRecord | |
| casa::DfJones | ********************************************************** DfJones (freq-dep D) (general) |
| casa::DflinJones | ********************************************************** DflinJones (freq-dep, linearized DJones) |
| casa::DfllsJones | ********************************************************** DfllsJones (freq-dep, LLS DJones solve, General apply) |
| casacore::DFTError | Error class for DFTServer class |
| casacore::DFTServer< T > | Class containing methods for doing n-D slow Fourier transforms |
| casa::dbus::Diagnostic | |
| casacore::DiracDFunction< T > | A one dimensional Dirac delta function |
| casacore::DiracDParam< T > | A one dimensional Dirac delta function |
| casacore::DirectionCoordinate | Interconvert pixel positions and directions (e.g. RA/DEC) |
| casacore::Directory | Get information about, and manipulate directories |
| casacore::DirectoryIterator | Traverse the contents of a directory |
| casa::DirItem | |
| casa::DirModel | |
| casacore::DiscreteUniform | Discrete uniform distribution |
| casa::DiskShape | A disk model for the spatial distribution of emission |
| casa::dbus::Dispatcher | |
| casa::Display | Enumerate constants for the display classes |
| casa::viewer::PVLine::display_element | One display_element is created for each image created from this PVLine |
| casa::viewer::hidden::display_panel_gui_status | Qt's meta object features not supported for nested classes |
| casa::DisplayCoordinateSystem | |
| casa::DisplayData | Base class for display objects |
| casa::DisplayData3 | |
| casa::DisplayDataEvent | Class for events sent by DisplayDatas |
| casa::DisplayDataHolder | Manages and controls access to a lit of QtDisplayDatas |
| casa::viewer::DisplayDataOptions | |
| casa::DisplayEH | Class for handling any type of DisplayEvent |
| casa::DisplayEnums_global_functions_DisplayEnums_to_string_functions | Global functions (operators) to print display class enumerations |
| casa::DisplayEvent | Class describing the most basic event information in the display classes |
| casa::DisplayLabel | Provides a quick view of a particular display property that has been set |
| casa::DisplayMethod | Base class for drawing a particular element (view) of a DisplayData |
| casa::DisplayOptions | Class to provide option parsing routines for display classes |
| casa::DisplayOptionsDialog | Opens up a dialog showing the display options that can be tweaked for a particular images |
| casa::DisplayParameter | Base class for storing and parsing of parameters for display classes |
| casa::DisplayPoint3 | |
| casa::DisplayShape | The abstract base class for all "DisplayShapes" |
| casa::DisplayShapeInterface | Class PixelCanvas; class WorldCanvas; |
| casa::DisplayShapeWithCoords | |
| casa::DisplayTool | Base class for event-based tools in the display classes |
| casa::DistributedSynthesisIterBot | Class that contains functions needed for imager |
| casa::DistributedSynthesisIterBotWithOldGUI | |
| casa::DistSIIterBot_state | |
| casacore::Divides< L, R, RES > | Functor to divide variables of possibly different types |
| casa::DJones | ********************************************************** DJones |
| casa::DJonesCorruptor | D is like ANoise but has a complex amplitude (different sigma in real/imag), and a systematic offset |
| casa::DJonesDesc | DJonesDesc: Define the format of DJones cal tables |
| casa::DJonesMBuf | DJonesMBuf: DJones calibration main table buffer |
| casa::DJonesMCol | DJonesMCol: RW DJones cal_main column access |
| casa::DJonesMRec | DJonesMRec: DJones cal_main table record access & creation |
| casa::DJonesTable | DJonesTable: DJones calibration table access and creation |
| casa::DLFont | A class designed to manage several representations of the same font |
| casa::DlHandle< T > | |
| casa::DlHandleBase | |
| casa::DlinJones | ********************************************************** DlinJones (linearized DJones) |
| casa::DllsJones | ********************************************************** DllsJones (LLS DJones solve, General apply) |
| casa::DlTarget | |
| casacore::DOos | DO for accessing os-specific functions |
| asdm::DopplerRow | Row of a DopplerTable |
| asdm::DopplerTable | Alma table |
| asdm::ASDMUtils::DotXMLFilter | |
| asdm::Double | A collection of static methods to perform conversions between strings and double values |
| casacore::Downcase | Functor to downcase a std::string |
| casa::DParameterButton | Implementation of DisplayParameter to package interface to button autoguis |
| casa::DParameterChoice | Implementation of DisplayParameter to store choice parameters |
| casa::DParameterColorChoice | Implementation of DParameterChoice to store color selection parameters |
| casa::DParameterFontChoice | Implementation of DParameterChoice to store font selection parameters |
| casa::DParameterMapKeyChoice | Implementation of DParameterChoice to store parameter and associated key |
| casa::DParameterRange< T > | A helper class to deal with data ranges to support options |
| casa::DParameterString | Implementation of DisplayParameter to store String parameters |
| casa::DParameterSwitch | Implementation of DisplayParameter to store choice parameters |
| casa::DrawingDisplayData | DisplayData which provides interactive drawing capabilities |
| casa::DrawingDisplayMethod | DisplayMethod which provides actual drawing for DrawingDisplayData class |
| casa::DriverParams | Parameters to indicate what driver should be used for the table backend |
| casa::DS9 | Contains common enums, constants, and methods for DS9 files |
| casa::viewer::ds9context | |
| casa::DS9Coordinate | Class to represent a single coordinate (value + unit) |
| casa::DS9FileReader | Implementation of RSFileReader for DS9 regions |
| casa::DS9FileWriter | Implementation of RegionFileWriter for writing to DS9 files |
| casa::viewer::ds9lex | Scanner is a derived class to add some extra function to the scanner class |
| casa::viewer::ds9parser | |
| casa::DS9Region | Holds information for read DS9 regions |
| casa::viewer::ds9writer | |
| casa::DSArrow | Arrow implementation;adds a polygon to a DSLine to represent the arrow head |
| casa::DSBasic | Base class for all "basic" shapes |
| casa::DSCircle | Circle implementation;extends DSEllipse, adding general circle functions |
| casa::DSClosed | DSClosed provides common functionality for all "closed" shapes |
| casa::DSEllipse | Implementation of a ellipse |
| casa::DSLine | Implementation of a line |
| casa::DSMarker | Implementation of a marker |
| casa::DSPixelArrow | |
| casa::DSPixelEllipse | |
| casa::DSPixelMarker | |
| casa::DSPixelPoly | |
| casa::DSPixelPolyLine | |
| casa::DSPixelRectangle | |
| casa::DSPixelText | |
| casa::DSPoly | Implementation of a Polygon |
| casa::DSPolyLine | Implementation of a polyline |
| casa::DSRectangle | Implementation of a rectangle |
| casa::DSScreenArrow | |
| casa::DSScreenEllipse | |
| casa::DSScreenMarker | |
| casa::DSScreenPoly | |
| casa::DSScreenPolyLine | |
| casa::DSScreenRectangle | |
| casa::DSScreenText | |
| casa::DSSquare | Implementation of a square |
| casa::DSText | Implementation of text |
| casa::DSWorldArrow | |
| casa::DSWorldEllipse | |
| casa::DSWorldMarker | |
| casa::DSWorldPoly | |
| casa::DSWorldPolyLine | |
| casa::DSWorldRectangle | |
| casa::DSWorldText | |
| casa::viewer::dtorNotifiee | |
| casa::viewer::dtorNotifier | |
| casa::DTVisible | Class providing draw style settings for visible DisplayTools |
| casacore::Dummy_Constants_class | Mathematical and numerical constants |
| casa::DummyBufferImpl | |
| casa::DummyClass | Removal of compile warnings for unused variables |
| casacore::DuplError | Duplicate key errors |
| casacore::duplError< t > | Duplicate key errors where the bad key is returned |
| asdm::DuplicateKey | Generate an exception when a new row cannot be inserted because it contains a duplicate key |
| casa::QtDataManager::dvo_working_item | |
| casacore::DynBuffer | Store data in dynamically allocated buffers |
| casacore::DynLib | Class to handle loading of dynamic libraries |
| casacore::EarthField | EarthField class model calculations |
| casacore::EarthMagneticMachine | Calculates magnetic field in a direction |
| casacore::EclecticFunctionFactory< T > | |
| casa::EGainCurve | ********************************************************** EGainCurve |
| casa::vi::FrequencySelectionUsingChannels::Element | |
| casa::vi::FrequencySelectionUsingFrame::Element | |
| casa::viewer::Ellipse | All regions are specified in "linear coordinates", not "pixel coordinates" |
| casacore::EmptyStackError | Error class for the Stack class |
| asdm::EndianIFStream | |
| asdm::EndianISStream | |
| asdm::EndianIStream | |
| asdm::EndianOSStream | |
| asdm::Entity | Identification of a persistant entity in the ALMA archive |
| asdm::EntityId | Description |
| asdm::EntityRef | Identification of a persistant entity in the ALMA archive |
| casa::Entropy | Base class for entropy functions as used by MEM |
| casa::EntropyEmptiness | Maximum Emptiness measure used by MEM |
| casa::EntropyI | Thermodynamic or Information entropy used by MEM |
| enum_map_traits< ACAPolarizationMod::ACAPolarization, void > | |
| enum_map_traits< AccumModeMod::AccumMode, void > | |
| enum_map_traits< AntennaMakeMod::AntennaMake, void > | |
| enum_map_traits< AntennaMotionPatternMod::AntennaMotionPattern, void > | |
| enum_map_traits< AntennaTypeMod::AntennaType, void > | |
| enum_map_traits< AssociatedCalNatureMod::AssociatedCalNature, void > | |
| enum_map_traits< AssociatedFieldNatureMod::AssociatedFieldNature, void > | |
| enum_map_traits< AtmPhaseCorrectionMod::AtmPhaseCorrection, void > | |
| enum_map_traits< AxisNameMod::AxisName, void > | |
| enum_map_traits< BasebandNameMod::BasebandName, void > | |
| enum_map_traits< BaselineReferenceCodeMod::BaselineReferenceCode, void > | |
| enum_map_traits< BinaryDataFlagsMod::BinaryDataFlags, void > | |
| enum_map_traits< CalCurveTypeMod::CalCurveType, void > | |
| enum_map_traits< CalDataOriginMod::CalDataOrigin, void > | |
| enum_map_traits< CalibrationDeviceMod::CalibrationDevice, void > | |
| enum_map_traits< CalibrationFunctionMod::CalibrationFunction, void > | |
| enum_map_traits< CalibrationModeMod::CalibrationMode, void > | |
| enum_map_traits< CalibrationSetMod::CalibrationSet, void > | |
| enum_map_traits< CalTypeMod::CalType, void > | |
| enum_map_traits< CorrelationBitMod::CorrelationBit, void > | |
| enum_map_traits< CorrelationModeMod::CorrelationMode, void > | |
| enum_map_traits< CorrelatorCalibrationMod::CorrelatorCalibration, void > | |
| enum_map_traits< CorrelatorNameMod::CorrelatorName, void > | |
| enum_map_traits< CorrelatorTypeMod::CorrelatorType, void > | |
| enum_map_traits< DataContentMod::DataContent, void > | |
| enum_map_traits< DataScaleMod::DataScale, void > | |
| enum_map_traits< DetectorBandTypeMod::DetectorBandType, void > | |
| enum_map_traits< DifferenceTypeMod::DifferenceType, void > | |
| enum_map_traits< DirectionReferenceCodeMod::DirectionReferenceCode, void > | |
| enum_map_traits< DopplerReferenceCodeMod::DopplerReferenceCode, void > | |
| enum_map_traits< DopplerTrackingModeMod::DopplerTrackingMode, void > | |
| enum_map_traits< FieldCodeMod::FieldCode, void > | |
| enum_map_traits< FilterModeMod::FilterMode, void > | |
| enum_map_traits< FluxCalibrationMethodMod::FluxCalibrationMethod, void > | |
| enum_map_traits< FocusMethodMod::FocusMethod, void > | |
| enum_map_traits< FrequencyReferenceCodeMod::FrequencyReferenceCode, void > | |
| enum_map_traits< HolographyChannelTypeMod::HolographyChannelType, void > | |
| enum_map_traits< InvalidatingConditionMod::InvalidatingCondition, void > | |
| enum_map_traits< NetSidebandMod::NetSideband, void > | |
| enum_map_traits< PointingMethodMod::PointingMethod, void > | |
| enum_map_traits< PointingModelModeMod::PointingModelMode, void > | |
| enum_map_traits< PolarizationTypeMod::PolarizationType, void > | |
| enum_map_traits< PositionMethodMod::PositionMethod, void > | |
| enum_map_traits< PositionReferenceCodeMod::PositionReferenceCode, void > | |
| enum_map_traits< PrimaryBeamDescriptionMod::PrimaryBeamDescription, void > | |
| enum_map_traits< PrimitiveDataTypeMod::PrimitiveDataType, void > | |
| enum_map_traits< ProcessorSubTypeMod::ProcessorSubType, void > | |
| enum_map_traits< ProcessorTypeMod::ProcessorType, void > | |
| enum_map_traits< RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode, void > | |
| enum_map_traits< ReceiverBandMod::ReceiverBand, void > | |
| enum_map_traits< ReceiverSidebandMod::ReceiverSideband, void > | |
| enum_map_traits< SBTypeMod::SBType, void > | |
| enum_map_traits< ScanIntentMod::ScanIntent, void > | |
| enum_map_traits< SchedulerModeMod::SchedulerMode, void > | |
| enum_map_traits< SidebandProcessingModeMod::SidebandProcessingMode, void > | |
| enum_map_traits< SourceModelMod::SourceModel, void > | |
| enum_map_traits< SpectralResolutionTypeMod::SpectralResolutionType, void > | |
| enum_map_traits< StationTypeMod::StationType, void > | |
| enum_map_traits< StokesParameterMod::StokesParameter, void > | |
| enum_map_traits< SubscanIntentMod::SubscanIntent, void > | |
| enum_map_traits< SwitchingModeMod::SwitchingMode, void > | |
| enum_map_traits< SynthProfMod::SynthProf, void > | |
| enum_map_traits< SyscalMethodMod::SyscalMethod, void > | |
| enum_map_traits< TimeSamplingMod::TimeSampling, void > | |
| enum_map_traits< TimeScaleMod::TimeScale, void > | |
| enum_map_traits< WeightTypeMod::WeightType, void > | |
| enum_map_traits< WindowFunctionMod::WindowFunction, void > | |
| enum_map_traits< WVRMethodMod::WVRMethod, void > | |
| enum_set_traits< ACAPolarizationMod::ACAPolarization > | |
| enum_set_traits< AccumModeMod::AccumMode > | |
| enum_set_traits< AntennaMakeMod::AntennaMake > | |
| enum_set_traits< AntennaMotionPatternMod::AntennaMotionPattern > | |
| enum_set_traits< AntennaTypeMod::AntennaType > | |
| enum_set_traits< AssociatedCalNatureMod::AssociatedCalNature > | |
| enum_set_traits< AssociatedFieldNatureMod::AssociatedFieldNature > | |
| enum_set_traits< AtmPhaseCorrectionMod::AtmPhaseCorrection > | |
| enum_set_traits< AxisNameMod::AxisName > | |
| enum_set_traits< BasebandNameMod::BasebandName > | |
| enum_set_traits< BaselineReferenceCodeMod::BaselineReferenceCode > | |
| enum_set_traits< BinaryDataFlagsMod::BinaryDataFlags > | |
| enum_set_traits< CalCurveTypeMod::CalCurveType > | |
| enum_set_traits< CalDataOriginMod::CalDataOrigin > | |
| enum_set_traits< CalibrationDeviceMod::CalibrationDevice > | |
| enum_set_traits< CalibrationFunctionMod::CalibrationFunction > | |
| enum_set_traits< CalibrationModeMod::CalibrationMode > | |
| enum_set_traits< CalibrationSetMod::CalibrationSet > | |
| enum_set_traits< CalTypeMod::CalType > | |
| enum_set_traits< CorrelationBitMod::CorrelationBit > | |
| enum_set_traits< CorrelationModeMod::CorrelationMode > | |
| enum_set_traits< CorrelatorCalibrationMod::CorrelatorCalibration > | |
| enum_set_traits< CorrelatorNameMod::CorrelatorName > | |
| enum_set_traits< CorrelatorTypeMod::CorrelatorType > | |
| enum_set_traits< DataContentMod::DataContent > | |
| enum_set_traits< DataScaleMod::DataScale > | |
| enum_set_traits< DetectorBandTypeMod::DetectorBandType > | |
| enum_set_traits< DifferenceTypeMod::DifferenceType > | |
| enum_set_traits< DirectionReferenceCodeMod::DirectionReferenceCode > | |
| enum_set_traits< DopplerReferenceCodeMod::DopplerReferenceCode > | |
| enum_set_traits< DopplerTrackingModeMod::DopplerTrackingMode > | |
| enum_set_traits< FieldCodeMod::FieldCode > | |
| enum_set_traits< FilterModeMod::FilterMode > | |
| enum_set_traits< FluxCalibrationMethodMod::FluxCalibrationMethod > | |
| enum_set_traits< FocusMethodMod::FocusMethod > | |
| enum_set_traits< FrequencyReferenceCodeMod::FrequencyReferenceCode > | |
| enum_set_traits< HolographyChannelTypeMod::HolographyChannelType > | |
| enum_set_traits< InvalidatingConditionMod::InvalidatingCondition > | |
| enum_set_traits< NetSidebandMod::NetSideband > | |
| enum_set_traits< PointingMethodMod::PointingMethod > | |
| enum_set_traits< PointingModelModeMod::PointingModelMode > | |
| enum_set_traits< PolarizationTypeMod::PolarizationType > | |
| enum_set_traits< PositionMethodMod::PositionMethod > | |
| enum_set_traits< PositionReferenceCodeMod::PositionReferenceCode > | |
| enum_set_traits< PrimaryBeamDescriptionMod::PrimaryBeamDescription > | |
| enum_set_traits< PrimitiveDataTypeMod::PrimitiveDataType > | |
| enum_set_traits< ProcessorSubTypeMod::ProcessorSubType > | |
| enum_set_traits< ProcessorTypeMod::ProcessorType > | |
| enum_set_traits< RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode > | |
| enum_set_traits< ReceiverBandMod::ReceiverBand > | |
| enum_set_traits< ReceiverSidebandMod::ReceiverSideband > | |
| enum_set_traits< SBTypeMod::SBType > | |
| enum_set_traits< ScanIntentMod::ScanIntent > | |
| enum_set_traits< SchedulerModeMod::SchedulerMode > | |
| enum_set_traits< SidebandProcessingModeMod::SidebandProcessingMode > | |
| enum_set_traits< SourceModelMod::SourceModel > | |
| enum_set_traits< SpectralResolutionTypeMod::SpectralResolutionType > | |
| enum_set_traits< StationTypeMod::StationType > | |
| enum_set_traits< StokesParameterMod::StokesParameter > | |
| enum_set_traits< SubscanIntentMod::SubscanIntent > | |
| enum_set_traits< SwitchingModeMod::SwitchingMode > | |
| enum_set_traits< SynthProfMod::SynthProf > | |
| enum_set_traits< SyscalMethodMod::SyscalMethod > | |
| enum_set_traits< TimeSamplingMod::TimeSampling > | |
| enum_set_traits< TimeScaleMod::TimeScale > | |
| enum_set_traits< WeightTypeMod::WeightType > | |
| enum_set_traits< WindowFunctionMod::WindowFunction > | |
| enum_set_traits< WVRMethodMod::WVRMethod > | |
| asdm::EnumerationParser | |
| casacore::EnvironmentVariable | This class allows for getting enviroment variables |
| asdm::EphemerisRow | Row of a EphemerisTable |
| asdm::EphemerisTable | Alma table |
| casa::EPJones | ********************************************************** EPJones (pointing errors) |
| casa::EPointDesc | EPointDesc: Define the format of GJones cal tables |
| casa::EPointMBuf | EPointMBuf: EPoint calibration main table buffer |
| casa::EPointMCol | EPointJonesMCol: RW SolvableVisJones cal_main column access |
| casa::EPointTable | |
| casa::EPointVisJonesMRec | EPointVisJonesMRec: EPointVisJones cal_main table record access/creation |
| casacore::Erlang | Erlang distribution |
| Error | |
| casa::dbus::variant::error | |
| casa::ErrorPlot | An error plot is a scatter plot with error bars drawn |
| casacore::Euler | Vector of Euler rotation angles |
| casacore::EvenPolynomial< T > | A one dimensional odd polynomial class |
| casacore::EvenPolynomial_PS< AutoDiff< T > > | Partial specialization of EvenPolynomial for AutoDiff |
| casacore::EvenPolynomialParam< T > | Parameter handling for even polynomials |
| casa::EVLAAperture | Class EVLAAperture : public ATerm |
| casa::refim::EVLAAperture | |
| casa::EVLAConvFunc | |
| casa::refim::EVLAConvFunc | |
| casa::EVLASwPow | ********************************************************** EVLA switched power Gain and Tsys |
| asdm::ExecBlockRow | Row of a ExecBlockTable |
| asdm::ExecBlockTable | Alma table |
| casa::ExecRecord | |
| casacore::Exp< T, RES > | Functor to apply exp |
| casa::ExpCache< T > | |
| casa::ExportThread | Exports a plot to a specific format in a background thread |
| casacore::FuncExprData::ExprCompState | The compilation state descriptor |
| casacore::FuncExprData::ExprOperator | The operator description: code; priority; # of arguments; # of arguments used up (or produced for functions) |
| casacore::ExpSincConv< T > | Exponential times a Sinc |
| casa::ExtendFlagger | |
| casacore::ExtendImage< T > | An extension of an ImageInterface object |
| casacore::ExtendLattice< T > | An extension of a Lattice or MaskedLattice |
| casacore::ExtendSpecifier | Specification of new and stretched lattice axes |
| casacore::ExtensionHeaderDataUnit | Base class for generalized exentensions HDU |
| casa::ExternalAxis | Overrides methods of QwtScaleDraw so that the axis can be enabled (supported) but the one drawn by the plot will take up no space and be invisible so that we can draw our own |
| casa::ExternalAxisControl | Base class for classes that use the QwtScaleDiv information to draw their own axis |
| casa::ExternalAxisControlBottom | |
| casa::ExternalAxisControlLeft | |
| casa::ExternalAxisControlRight | |
| casa::ExternalAxisWidget | Base class for classes that use the QwtScaleDiv information to draw their own axis |
| casa::ExternalAxisWidgetBottom | |
| casa::ExternalAxisWidgetHorizontal | Common code for drawing a horizontal axis external to the plot |
| casa::ExternalAxisWidgetLeft | |
| casa::ExternalAxisWidgetRight | |
| casa::ExternalAxisWidgetTop | |
| casa::ExternalAxisWidgetVertical | Common code for drawing a vertical axis external to the plot |
| casacore::ExternalLockSync | Class to hold table lock data |
| casa::functor::f | |
| casa::functor::f00< C > | |
| casa::functor::f01< C, P1 > | |
| casa::functor::f02< C, P1, P2 > | |
| casa::functor::f03< C, P1, P2, P3 > | |
| casa::functor::f04< C, P1, P2, P3, P4 > | |
| casa::functor::f_ | |
| casa::ROVisibilityIterator::Factory | VLAT should not access private parts, especially variables |
| casa::vi::VisibilityIterator2::Factory | |
| casa::ROVisIterator::Factory | |
| casa::VisIterator::Factory | |
| casacore::Fallible< T > | Mark a value as valid or invalid |
| casacore::Fallible_global_functions_invalid_access | Throw exception on access of an invalid object This function gets called when an invalid object is accessed. It just throws an exception. Since we have inline functions, let's keep the throw out of them to keep them from moving out of line |
| casa::fBM | This generates fractional brownian motion aka generalized 1/f noise class fBM : public Array<Double> { |
| casa::Feather | Class that contains functions needed for feathering |
| casa::FeatherCurve | Represents a curve on one of the plots |
| casa::FeatherCurveType | An enumeration of the different curves that a user can ask to be displayed on the plot |
| casa::FeatherDataType | An enumeration of the different kinds of data that can be graphed on the plot |
| casa::FeatheredData | Data structure class to collect related feather data in one location |
| casa::FeatherMain | |
| casa::FeatherManager | Does image/data manapulation and stores/provides data |
| casa::FeatherPlot | |
| casa::FeatherPlotWidget | |
| casa::FeatherPlotWidgetScatter | A specialization of FeatherPlotWidget for scatter plots |
| casa::FeatherPlotWidgetSlice | A specialization of FeatherPlotWidget for displaying line plots |
| casa::FeatherThread | Gathers up the data from the feathering process and stores it |
| asdm::FeedRow | Row of a FeedTable |
| asdm::FeedTable | Alma table |
| casa::FFT2D | |
| casacore::FFTEnums | Lists the different types of FFT's that can be done |
| casacore::FFTPack | C++ interface to the Fortran FFTPACK library |
| casacore::FFTServer< T, S > | A class with methods for Fast Fourier Transforms |
| casacore::FFTW | C++ interface to the FFTWw library |
| casa::FieldCalMap | |
| casacore::FieldNotFoundError | |
| casa::sdfiller::FieldRecord | |
| asdm::FieldRow | Row of a FieldTable |
| asdm::FieldTable | Alma table |
| casacore::File | Class to get file information and a base for other file classes |
| file | Defines nreal time structures used by the VLA table filler |
| casa::FileBox | |
| casacore::FilebufIO | Class for buffered IO on a file |
| casa::FileCatalog | |
| casacore::FiledesIO | Class for unbuffered IO on a file |
| casa::FileLoader | |
| casacore::FileLocker | Class to handle file locking |
| casa::FileWatcher | |
| casa::asyncio::VLAT::FillerDictionary | |
| casa::vi::VLAT::FillerDictionary | |
| FillMetadata | Container for storing the Miriad metadata that must be tracked while filling |
| casa::viewer::filter< T, CT > | |
| casa::final< DataIterator > | Data provider for antenna1 column |
| casa::vi::FinalTvi2 | FinalTvi2 - Class that serves as the final Tvi2 in a pipeline; it adds simple write functionality that allows writing back the data contained in the associated VB2 |
| casa::FindSourcesDialog | Displays a dialog that allows the user to find and edit a source list that can be used as estimates for a 2D fit |
| casa::utilj::FirstFunctor< F, S > | |
| casa::CalStatsFitter::FIT | FIT nested class |
| casacore::Fit2D | Fit 2-D objects to 2-D Lattices or Arrays |
| casa::Fit2DLogDialog | |
| casa::Fit2DTool | |
| casacore::FitGaussian< T > | Multidimensional fitter class for Gaussians |
| casacore::FITS | Static functions and enumerations |
| casacore::FITS2_global_functions_ReadFITSin | Helper function for ReadFITS and WriteFITS |
| casacore::FitsArray< TYPE > | FITS array of given type |
| casacore::FitsArray< FitsBit > | FITS array of FitsBit type Note: We must specify a FitsArray<FitsBit> as a specialization; |
| casacore::FitsBase | Helper class |
| casacore::FitsBit | Helper class for FITS Binary Tables |
| casacore::FITSCoordinateUtil | |
| casacore::FITSDateUtil | A class with static functions to help deal with FITS dates |
| casacore::FitsDiskInput | FITS input from disk |
| casacore::FitsDiskOutput | FITS output to disk |
| casacore::FITSError | Default FITS error handling function, typdef, and enumeration |
| casacore::FITSErrorImage | Class providing native access to FITS Error images |
| casacore::FITSExtInfo | Class FitsKeywordList; |
| casacore::FitsField< TYPE > | Helper class Note: Note that FitsField does not allocate space for the data; Space is external to FitsField and its address is set via the setaddr function; |
| casacore::FitsField< FitsBit > | Helper class |
| casacore::FITSFieldCopier | Virtual base class for copying RORecordFields to FitsFields |
| casacore::FitsFPUtil | Utility functions for floating point values |
| casacore::FITSGroupWriter | Simplified interface to create and write to FITS random groups |
| casacore::FITSHistoryUtil | A class with static functions to help deal with FITS History cards |
| casacore::FITSIDItoMS1 | FITSIDItoMS converts a FITS-IDI file to a CASA Measurement Set |
| casacore::FITSImage | Class providing native access to FITS images |
| casacore::FITSImgParser | Class for handling FITS Image extensions |
| casacore::FitsInput | Fixed-length sequential blocked FITS input |
| casacore::FitsIO | Sequential FITS I/O |
| casacore::FitsKeyCardTranslator | Translator between Keyword lists and fixed FITS cars |
| casacore::FitsKeyword | FITS keyword |
| casacore::FitsKeywordList | Linked list of FITS keywords |
| casacore::FITSKeywordUtil | A class with static functions to help deal with FITS Keywords |
| casacore::FitsLogical | FITS helper class |
| casacore::FITSMask | Provides an on-the-fly mask for FITS images |
| casacore::FITSMultiTable | View multiple FITS files as a single table |
| casacore::FitsNameResult | Analyse the name of a header card |
| casacore::FitsOutput | Fixed-length sequential blocked FITS output |
| casacore::FitsParse | Parse a header card |
| casacore::FITSQualityImage | Class providing native access to FITS Quality Images |
| casacore::FITSQualityMask | Provides an on-the-fly mask for FITS quality images |
| casacore::FITSReader | |
| casacore::FITSSpectralUtil | A class with static functions to help deal with FITS spectral axes |
| casacore::FitsStdInput | FITS input from standard input |
| casacore::FitsStdOutput | FITS output to standard output |
| casacore::FITSTable | Attach a FITSTabular to a binary or ASCII table |
| casacore::FITSTableWriter | Simplified interface to create and write to a FITS Binary Table |
| casacore::FITSTabular | Simplified interface to FITS tables with Casacore Look and Feel |
| casacore::FitsTape9Input | FITS input from 9-track tape |
| casacore::FitsTape9Output | FITS output to 9-track tape |
| casacore::FITSTimedTable | |
| casacore::FitsVADesc | Variable Length Array Descriptor |
| casacore::FitsValueResult | Analyse the value of a header card |
| casa::Fitter | Base class for classes performing histogram fits |
| casa::FitterEstimatesFileParser | Class for parsing a file which holds initial estimates for 2-D components. Used by imfit |
| casa::FitterGaussian | Manages Gaussian initial guesses and fits Gaussian curves to the histogram |
| casa::FitterPoisson | Fits Poisson curves to the histogram |
| casacore::FittingProxy | This class gives Proxy to Fitting connection |
| casacore::FitToHalfStatistics< AccumType, DataIterator, MaskIterator, WeightsIterator > | Class to calculate statistics using the so-called fit to half algorithm |
| casacore::FitToHalfStatisticsData | Various data for FitToHalfStatistics |
| casacore::FittingProxy::FitType | Class to aid in distributing different fitters |
| casa::FitWidget | Main class for handling the pluggable fit functionality for the histogram |
| casa::FixVis | Performs for MeasurementSets various fixes which do not involve calibrating. This includes (in order of implementation): 1. Generating and inserting (u, v, w)s into a MS that may or may not already have them. Includes antenna offsets when known. 2. Correcting for differential aberration. 3. Changing the phase tracking center. 4. Changing the equinox (B1950 -> J2000). 5. (maybe never) Changing the projection, i.e. SIN <-> (-)NCP |
| casa::FJones | |
| casa::FlagAgentBase | A top level class defining the interface for flagging agents |
| casa::FlagAgentClipping | |
| casa::FlagAgentDisplay | |
| casa::FlagAgentElevation | |
| casa::FlagAgentExtension | |
| casa::FlagAgentList | |
| casa::FlagAgentManual | |
| casa::FlagAgentQuack | |
| casa::FlagAgentRFlag | |
| casa::FlagAgentShadow | |
| casa::FlagAgentSummary | |
| casa::FlagAgentTimeFreqCrop | |
| casa::FlagCalTableHandler | Flag Data Handler class definition |
| asdm::FlagCmdRow | Row of a FlagCmdTable |
| asdm::FlagCmdTable | Alma table |
| casa::FlagDataHandler | A top level class defining the data handling interface for the flagging module |
| casa::MSAsRaster::FlagEdit_ | |
| casa::Flagger | Flagger: high-performance automated flagging |
| casa::FlaggerEnums | FlaggerEnums: collection of enums for various flagger classes |
| casa::FlagID | |
| casa::FlagIDS | Class for flaging and extend flagging |
| casa::FlagMapper | |
| casa::FlagMSHandler | Flag Data Handler class definition |
| casa::FlagPlotServerProxy | |
| casa::FlagReport | Everything going into the FlagReport is by value Everything going out of it is by reference |
| asdm::FlagRow | Row of a FlagTable |
| casacore::BitFlagsEngine< StoredType >::FlagsToBool | Functor to and an array and mask and convert to Bool |
| asdm::FlagTable | Alma table |
| casa::FlagVersion | Class to generate and manage flag versions for Tables containing flag columns |
| FlexLexer | |
| asdm::Float | A collection of static methods to perform conversions between strings and float values |
| casacore::Floor< T, RES > | Functor to apply floor |
| casacore::FloorMod< L, R, RES > | Functor to take modulo of variables of possibly different types using the floor modulo (% as used in Python) |
| casa::FlowLayout | |
| casa::Flux< T > | A class that represents the Flux (reference semantics) |
| asdm::Flux | Implements a quantity of flux in janskys |
| casa::FluxCalc_SS_JPL_Butler | Class ROScalarColumn<Double>; There doesn't seem to be a way to forward declare a template |
| casa::FluxCalcLogFreqBrokenPolynomial | FluxCalcLogFreqBrokenPolynomial: Implementation base class for flux standards which are broken polynomials of log10(frequency) |
| casa::FluxCalcLogFreqPolynomial | FluxCalcLogFreqPolynomial: Implementation base class for flux standards which are polynomials of log10(frequency) |
| casa::FluxCalcLogFreqPolynomialSH | FluxCalcLogFreqPolynomialSH: Implementation base class for flux standards which are polynomials of log10(frequency) following Scaife & Heald (2012) |
| casa::FluxCalcQS | Class Vector; |
| casa::FluxCalcVQS | Class Vector; |
| casa::FluxRep< T > | A class that represents the Flux (copy semantics) |
| casa::SolvableVisCal::fluxScaleStruct | |
| casa::FluxStandard | FluxStandard: Compute flux densities for standard reference sources |
| casa::FluxStdBaars | FluxStdBaars: The Baars flux standard |
| casa::NSTDS::FluxStdBaars | FluxStdBaars: The Baars flux standard |
| casa::FluxStdPerley90 | FluxStdPerley90: The Perley90 flux standard |
| casa::NSTDS::FluxStdPerley90 | FluxStdPerley90: The Perley90 flux standard |
| casa::FluxStdPerleyButler2010 | FluxStdPerleyButler2010: The PerleyButler2010 flux standard |
| casa::NSTDS::FluxStdPerleyButler2010 | FluxStdPerleyButler2010: The PerleyButler2010 flux standard |
| casa::FluxStdPerleyButler2013 | FluxStdPerleyButler2013: The PerleyButler2013 flux standard |
| casa::NSTDS::FluxStdPerleyButler2013 | FluxStdPerleyButler2013: The PerleyButler2013 flux standard |
| casa::FluxStdPerleyTaylor95 | FluxStdPerleyTaylor95: The PerleyTaylor95 flux standard |
| casa::NSTDS::FluxStdPerleyTaylor95 | FluxStdPerleyTaylor95: The PerleyTaylor95 flux standard |
| casa::FluxStdPerleyTaylor99 | FluxStdPerleyTaylor99: The PerleyTaylor99 flux standard |
| casa::NSTDS::FluxStdPerleyTaylor99 | FluxStdPerleyTaylor99: The PerleyTaylor99 flux standard |
| casa::NSTDS::FluxStdScaifeHeald2012 | FluxStdScaifeHeald2012: The Scaife & Heald (2012) flux standard |
| casa::FluxStdSrcs | Basic calibrator data used in the flux standards |
| casa::NSTDS::FluxStdStevensReynolds2016 | FluxStdStevensReynolds: The StevensReynolds2016 flux standard |
| casacore::Fmod< L, R, RES > | Functor to apply fmod |
| asdm::FocusModelRow | Row of a FocusModelTable |
| asdm::FocusModelTable | Alma table |
| asdm::FocusRow | Row of a FocusTable |
| asdm::FocusTable | Alma table |
| casa::FootPrintWidget | |
| casacore::MVAngle::Format | Format structure |
| casacore::MVTime::Format | Format structure |
| casacore::ForwardColumn | Virtual column forwarding to another column |
| casacore::ForwardColumnEngine | Virtual column engine forwarding to other columns |
| casacore::ForwardColumnIndexedRow | Virtual column forwarding to another row/column |
| casacore::ForwardColumnIndexedRowEngine | Virtual column engine forwarding to other columns/rows |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::FractileFunc< T > | |
| casa::vi::FreqAxisTransformEngine | |
| casa::vi::FreqAxisTransformEngine2 | |
| casa::vi::FreqAxisTVI | |
| asdm::FreqOffsetRow | Row of a FreqOffsetTable |
| asdm::FreqOffsetTable | Alma table |
| asdm::Frequency | Implements a quantity of frequency in hertz |
| casacore::FrequencyAligner< T > | Aligns spectra in frequency space |
| casa::vi::VisBufferState::FrequencyCache< T > | |
| casa::vi::FrequencySelection | |
| casa::vi::FrequencySelections | |
| casa::vi::FrequencySelectionUsingChannels | |
| casa::vi::FrequencySelectionUsingFrame | |
| casa::FringeJones | Fringe-fitting (parametrized phase) VisCal |
| casa::FTMachine | Defines interface for the Fourier Transform Machine |
| casa::refim::FTMachine | Defines interface for the Fourier Transform Machine |
| casacore::FuncExprData | Data and enumerations for functional expressions |
| casacore::FuncExprData_global_functions_output | Output function |
| casacore::FuncExpression | An expression executable as function |
| casacore::FuncExpression_global_functions_execute | Execute function |
| casacore::FuncExpression_global_functions_output | Output function |
| casacore::FuncId | Function ID, for use by MathFunc class |
| casacore::FunctionHolder< T >::FuncStat | Structure to hold functional status |
| casacore::Function< T, U > | Numerical functional interface class |
| casacore::Function1D< T, U > | Numerical functional interface class for 1 dimension |
| casacore::Function_global_functions_Output | Global functions |
| casacore::Functional< Domain, Range > | Map a domain object into a range object via operator() |
| casacore::FunctionalProxy | |
| casacore::FunctionFactory< T > | Class for creating Function objects from Records |
| casacore::FunctionFactoryError | |
| casacore::FunctionHolder< T > | A holder for Functions to enable record conversions |
| casacore::FunctionMarshallable | Class for serializing/reconstituting Function objects to/from Records |
| casacore::FunctionOrder< T > | Container of function description details |
| casacore::FunctionOrder_global_functions_Output | Global functions |
| casacore::FunctionParam< T > | Container of function parameters with masking flags |
| casacore::FunctionParam_global_functions_Output | Global functions |
| casacore::FunctionTraits< T > | Function data types for parameters and arguments |
| casacore::FunctionTraits_P< AutoDiff< T > > | FunctionTraits specialization for AutoDiff |
| casacore::FunctionTraits_PA< AutoDiffA< T > > | FunctionTraits specialization for AutoDiffA |
| casacore::FunctionTraits_PX< AutoDiffX< T > > | FunctionTraits specialization for AutoDiffX |
| casacore::FunctionWrapper< T > | Construct nD function objects from C++ functions |
| casa::FVisJonesDesc | FVisJonesDesc: Define the format of FVisJones cal tables |
| casa::FVisJonesIonoDesc | FVisJonesIonoDesc: Define the format of FVisJonesIono cal tables |
| casa::FVisJonesIonoMRec | FVisJonesIonoMRec: FVisJonesIono cal_main table record access/creation |
| casa::FVisJonesMRec | FVisJonesMRec: FVisJones cal_main table record access/creation |
| asdm::GainTrackingRow | Row of a GainTrackingTable |
| asdm::GainTrackingTable | Alma table |
| casa::Galaxy | Simple class to represent a Galaxy as a collection of Stars |
| casacore::Gaussian1D< T > | A one dimensional Gaussian class |
| casacore::Gaussian1D_PS< AutoDiff< T > > | Partial specialization of Gaussian1D for AutoDiff |
| casacore::Gaussian1DParam< T > | Parameter handling for one dimensional Gaussian class |
| casacore::Gaussian2D< T > | A two dimensional Gaussian class |
| casacore::Gaussian2D_PS< AutoDiff< T > > | Partial specialization of Gaussian2D for AutoDiff |
| casa::Gaussian2DFitter | Performs a 2DGaussian fit of an image in a background thread |
| casacore::Gaussian2DParam< T > | Parameter handling for 2 dimensional Gaussian class |
| casacore::Gaussian3D< T > | A three dimensional Gaussian class |
| casacore::Gaussian3D_PS< AutoDiff< T > > | Partial specialization of Gaussian3D for AutoDiff |
| casacore::Gaussian3DParam< Type > | Parameter handling for 3 dimensional Gaussian class |
| casacore::GaussianBeam | Represents a Gaussian restoring beam associated with an image |
| casacore::GaussianConv< T > | Gaussian |
| casacore::GaussianConvert | Converts Gaussian parameters between pixel and world |
| casa::GaussianDeconvolver | Deconvolve a gaussian source from a gaussian beam |
| casa::GaussianEstimateDialog | |
| casa::GaussianEstimateWidget | |
| casa::GaussianMultipletSpectralElement | Describes a multiplet of Gaussian shaped spectral lines |
| casacore::GaussianND< T > | A Multi-dimensional Gaussian functional |
| casacore::GaussianNDParam< T > | A Multi-dimensional Gaussian parameter handling |
| casa::GaussianShape | A Gaussian model for the spatial distribution of emission |
| casa::GaussianSpectralElement | Describes a Gaussian spectral line |
| casacore::generic_global_functions_def | Generic gnu macros |
| casacore::GenericL2Fit< T > | Generic base class for least-squares fit |
| casacore::GenSort< T > | General in-place sort functions |
| casacore::GenSortIndirect< T > | General indirect sort functions |
| casacore::Geometric | Discrete geometric distribution |
| casacore::Geometry | Geometry related methods |
| casacore::GetCellSlices< T > | Functor to get irregular array slices from a cell |
| casacore::GetColumnSlices< T > | Functor to get irregular array slices from a column |
| casa::GJones | ********************************************************** GJones |
| casa::GJonesCorruptor | |
| casa::GJonesDelayRateSBDesc | GJonesDelayRateSBDesc: Define the format of GJonesDelayRateSB cal tables |
| casa::GJonesDelayRateSBTable | GJonesDelayRateSBTable: GJonesDelayRateSB calibration table access and creation |
| casa::GJonesDesc | GJonesDesc: Define the format of GJones cal tables |
| casa::GJonesMBuf | GJonesMBuf: GJones calibration main table buffer |
| casa::GJonesMCol | GJonesMCol: RW GJones cal_main column access |
| casa::GJonesMRec | GJonesMRec: GJones cal_main table record access & creation |
| casa::GJonesPolyDesc | GJonesPolyDesc: Define the format of GJonesPoly cal tables |
| casa::GJonesPolyMBuf | GJonesPolyMBuf: GJonesPoly calibration main table buffer |
| casa::GJonesPolyMCol | GJonesPolyMCol: RW GJonesPoly cal_main column access |
| casa::GJonesPolyTable | GJonesPolyTable: GJonesPoly calibration table access/creation |
| casa::GJonesSpline | |
| casa::GJonesSplineDesc | GJonesSplineDesc: Define the format of GJonesSpline cal tables |
| casa::GJonesSplineMBuf | GJonesSplineMBuf: GJonesSpline calibration main table buffer |
| casa::GJonesSplineMCol | GJonesSplineMCol: RW GJonesSpline cal_main column access |
| casa::GJonesSplineTable | GJonesSplineTable: GJonesSpline calibration table access/creation |
| casa::GJonesTable | GJonesTable: GJones calibration table access and creation |
| casa::GlinXphfJones | Freq-dep XY-phase |
| casa::GlinXphJones | X-Y phase |
| casa::GLLogIO | GLLogIO adds tracing support to the AIPS++ LogIO object |
| casa::GLPixelCanvas::GLPCColorValue | Holds both a color index and RGBA values |
| casa::GLPCDisplayList | DisplayListElement that can contain lists of other DisplayListElements |
| casa::GLPCDisplayListElement | Base class for the various display list subclasses |
| casa::GLPCDisplayListEntry | Returns a Display List Element for recording GL commands |
| casa::GLPCTexturedImage | |
| casa::GLPCTextureParams | Holds parameters for setting glTexParameteri variables. <visibility=local> |
| casa::GLPixelCanvas | OpenGL implementation of PixelCanvas |
| casa::GLPixelCanvasColorTable | |
| casa::GLVColorTableEntry | Implementation of PixelCanvasColorTable for OpenGL |
| casa::GLWidget | |
| casacore::GNoiseFunction< T > | A one dimensional normal distribution |
| casacore::GNoiseParam< T > | A one dimensional normal distribution |
| casa::GraphLabel | |
| casa::GridBoth | |
| casacore::Gridder< Domain, Range > | A base class for gridding |
| casa::GridFT | An FTMachine for Gridded Fourier transforms |
| casa::refim::GridFT | An FTMachine for Gridded Fourier transforms |
| casa::PlotMSPlotParameters::Group | Static // |
| casa::GroupProcessor | Class Block; class MeasurementSet; |
| casa::GroupWorker | A base class for GroupWorkers that can modify their input MS |
| casa::GroupWorkerBase | Abstract base class for GroupWorkers |
| casa::GroupWriteToNewMS | A base class for ROGroupWorkers that write to a new MS |
| casa::denoising::GslLinearModelBase | |
| casa::denoising::GslMultifitLinearBase | |
| casa::denoising::GslMultifitWeightedLinear | |
| casa::denoising::GslPolynomialModel | |
| casa::viewer::guiwait | |
| casacore::HaDecColumn | Hourangle/declination derived from TIME, etc |
| casa::vi::HanningSmoothTVI | |
| casa::vi::HanningSmoothTVIFactory | |
| casacore::HashClass< key > | Hash function with state |
| casacore::HashMap< key, val > | Associative Array with a hash table implementation |
| casacore::HashMap_global_functions_defaulthashvalue | Specify the default values for HashMap keys |
| casacore::HashMap_global_functions_hashfunc | Hash functions for standard types |
| casacore::HashMapIO_global_functions_hashmapio | HashMap/HashMapIter IO functions |
| casacore::HashMapIter< key, val > | Step through a non-const HashMap |
| casacore::HDF5DataSet | A class representing an HDF5 data set |
| casacore::HDF5DataType | A class representing an HDF5 data type |
| casacore::HDF5Error | Base error class for HDF5 wrapper classes |
| casacore::HDF5File | A class representing an HDF5 file |
| casacore::HDF5Group | A class representing an HDF5 group |
| casacore::HDF5HidAttribute | A class representing an HDF5 attribute hid |
| casacore::HDF5HidDataSpace | A class representing an HDF5 dataspace hid |
| casacore::HDF5HidDataType | A class representing an HDF5 datatype hid |
| casacore::HDF5HidProperty | A class representing an HDF5 property hid |
| casacore::HDF5Image< T > | Read, store, and manipulate astronomical images in HDF5 format |
| casacore::HDF5Lattice< T > | A Lattice that is read from or written to an HDF5 dataset |
| casacore::HDF5LattIter< T > | A read/write Lattice iterator for PagedArrays |
| casacore::HDF5Object | An abstract base class representing an HDF5 object |
| casacore::HDF5Record | A class to write/read a record into HDF5 |
| casacore::HeaderDataUnit | Base class that defines a HDU |
| asdmbinaries::HeaderParser | Class HeaderParser |
| casa::HeightSource | |
| casacore::HelpMsCalUDF | |
| casa::HetArrayConvFunc | |
| casa::refim::HetArrayConvFunc | |
| casacore::HingesFencesStatistics< AccumType, DataIterator, MaskIterator, WeightsIterator > | Class to calculate statistics using the so-called hinges and fences algorithm |
| casacore::HistAcc< T > | Makes a histogram from input values |
| casa::Histogram | Generates and Manages the data corresponding to a histogram |
| casa::Histogram2dDD | A DisplayData to draw histograms |
| casa::Histogram2dDM | A DisplayMethod to draw histograms |
| casa::HistogramGraph | Displays a histogram specific to a region and an image; contains a "Next" button that toggles to a histogram displaying the same region, but a different image |
| casa::HistogramMain | Used when the histogram needs to come up as a main window |
| casa::HistogramMarkerGaussian | Marks initial (center,peak) and FWHM Gaussian estimates on the histogram |
| casa::HistogramMarkerPoisson | Marks a lambda estimate on the graph |
| casa::HistogramTab | Manages a stack widget that displays histograms for a single region but multiple images |
| asdm::HistoryRow | Row of a HistoryTable |
| asdm::HistoryTable | Alma table |
| casacore::HistTiledCollapser< T > | Generate histograms, tile by tile, from a masked lattice |
| casa::HogbomCleanImageSkyModel | Hogbom Clean Image Sky Model: Image Sky Model implementing the Hogbom Clean algorithm |
| casa::HogbomCleanModel< T > | A Class for performing Hogbom Clean's of Arrays |
| asdm::HolographyRow | Row of a HolographyTable |
| asdm::HolographyTable | Alma table |
| casacore::HostInfo | Miscellaneous information about this host and process |
| casacore::HourangleColumn | Hourangle derived from TIME, etc |
| HSV_Conversion_Functions | Utilities for converting between color spaces |
| asdm::Humidity | Implements a quantity of humidity in percent |
| casacore::HyperGeometric | Hypergeometric distribution |
| casacore::HyperPlane< T > | A hyper plane function |
| casacore::HyperPlane_PS< AutoDiff< T > > | Partial specialization of HyperPlane for AutoDiff |
| casacore::HyperPlaneParam< T > | Parameter handling for a hyper plane function |
| casacore::IBMConversion | A class with static functions to convert IBM format |
| casacore::IBMDataConversion | A class with virtual functions to convert IBM format |
| casa::IChangeDetector | |
| casa::refim::IChangeDetector | |
| casacore::IComplex | Integer complex numbers |
| IDIndex | Simple mapping from one indexing system to another |
| casa::IDL | A class to start IDL and execute commands, etc |
| enumerations::IDLConversionException | Exception when an error occurs in converting in restoring an Enumeration constant from its IDL representation |
| asdm::IllegalAccessException | Exception when an error occurs in converting a table to its external representation or in restoring a table from one of its external representations |
| casa::IlluminationConvFunc | |
| casa::refim::IlluminationConvFunc | |
| casacore::Imag< T, RES > | Functor to apply complex function imag |
| casa::Image1DSmoother< T > | |
| casa::Image2DConvolver< T > | This class does 2D convolution of an image by a functional form |
| casa::viewer::qt::image_stats_t | |
| casa::ImageAnalysis | Template<class T> class ImageHistograms; |
| casacore::ImageAttrGroup | Abstract base class for an image attributes group |
| casacore::ImageAttrGroupCasa | Attribute group for a CASA image |
| casacore::ImageAttrGroupHDF5 | Attribute group for a HDF5 image |
| casacore::ImageAttrHandler | Abstract base class for an image attributes handler |
| casacore::ImageAttrHandlerCasa | Abstract base class for an image attributes handler |
| casacore::ImageAttrHandlerHDF5 | Abstract base class for an image attributes handler |
| casacore::ImageBeamSet | Represents a set of restoring beams associated with an image |
| casa::ImageBoxcarSmoother< T > | |
| casa::ImageCollapser< T > | |
| casa::ImageCollapserData | |
| casacore::ImageConcat< T > | Concatenates images along a specified axis |
| casa::ImageConcatenator< T > | |
| casa::ImageConvolver< T > | This class does convolution of an image by an Array or Lattice |
| casa::ImageConvolverTask< T > | This class is the high level interface to image convolving |
| casa::ImageCropper< T > | |
| casa::ImageDataSampling | Provides sampling of single dish data for esimation algorithms |
| casa::ImageDecimator< T > | |
| casa::ImageDecimatorData | |
| casa::ImageDecomposer< T > | A tool to separate a complex image into individual components |
| casa::ImageDecomposerTask< T > | |
| casa::ImageDisplayer | Interface implemented by QtDisplayPanel that can add/remove registered DDs and set the controlling QtDisplayData's |
| casacore::ImageExpr< T > | Hold mathematical expressions involving ImageInterface objects |
| casa::ImageExprCalculator< T > | |
| casacore::ImageExprGram_global_functions_ImageExprGramFunctions | Global functions for flex/bison scanner/parser for ImageExprGram |
| casacore::ImageExprParse | Class to hold values from image expression parser |
| casacore::ImageExtension< TYPE > | IMAGE extension of given type |
| casa::ImageFactory | |
| casa::ImageFFT | FFT an image |
| casa::ImageFFTer< T > | |
| casa::ImageFit1D< T > | Fit spectral components to a Vector of data from an image |
| casacore::ImageFITSConverter | Interconvert between Casacore Images and FITS files |
| casacore::ImageFITSConverterImpl< HDUType > | This class is an internal class for ImageFITSConverter |
| casacore::ImageFITSHeaderInfo | Struct holding information derived from the image and its header |
| casa::ImageFitter | |
| casa::ImageFitterResults | |
| casa::ImageHanningSmoother< T > | |
| casa::ImageHistograms< T > | Displays histograms of regions from an image |
| casa::ImageHistogramsCalculator | This class computes histograms of image pixel values |
| casa::ImageHistory< T > | |
| casacore::ImageInfo | Miscellaneous information related to an image |
| casacore::ImageInfo_global_functions_Output | Global functions |
| casa::ImageInputProcessor | |
| casacore::ImageInterface< T > | A base class for astronomical images |
| casa::ImageLoader | Loads image files when the histogram runs as a standalone app |
| casa::ImageManagerDialog | Allows users to manipulate the images loaded in the viewer |
| casa::ImageMask | Static functions for interrogating image masks |
| casa::ImageMaskAttacher | Contains tatic method to attach a mask to an image |
| casa::ImageMaskedPixelReplacer< T > | |
| casa::ImageMaskHandler< T > | |
| casa::ImageMaxFitter< T > | |
| casa::ImageMetaData | A class in which to store and allow read-only access to image metadata |
| casa::ImageMetaDataBase | Base class for image metadata access |
| casa::ImageMetaDataRW | A class in which to store and allow read-write access to image metadata |
| casa::ImageMoments< T > | This class generates moments from an image |
| casa::ImageMomentsProgress | |
| casa::ImageMomentsProgressMonitor | This is just an interface class for monitoring the progress of collapsing and image through calculating a moment |
| casa::ImageMomentsTask< T > | |
| casa::ImageMSCleaner | A class interfacing images to MatrixCleaner |
| casa::ImageNACleaner | A class interfacing images to MatrixNACleaner |
| casacore::ImageOpener | Definition of image types and handlers |
| casa::ImagePadder | |
| casa::ImagePol | Implementation of the image polarimetry functionality available from casapy |
| casa::ImagePolarimetry | Polarimetric analysis of images |
| casa::ImagePrimaryBeamCorrector | |
| casa::ImageProfileFitter | |
| casa::ImageProfileFitterResults | |
| casa::viewer::ImageProperties | This class provides a priori image information derived from the image itself |
| casacore::ImageProxy | |
| casa::Imager | Class that contains functions needed for imager |
| casa::ImagerControl | |
| casa::ImageRebinner< T > | |
| casacore::ImageRegion | Class to hold a region of interest in an image |
| casa::viewer::ImageRegion_state | |
| casa::viewer::ImageRegionInfo | |
| casacore::ImageRegrid< T > | This regrids one image to match the coordinate system of another |
| casa::ImageRegridder | |
| casa::ImageRegridderBase< T > | |
| casa::ImagerMultiMS | |
| casa::ImageRotator | This class rotates an image through a specified angle |
| casa::ImageScroll | Displays a list of images, allowing the user to reorder them |
| casa::ImageSkyModel | Image Sky Model: Image-based Model for the Sky Brightness |
| casa::ImageSlice | Represents a slice cut of an image |
| casa::ImageSliceColorBar | Draws a colored rectangular bar across the top of the image slice statistics as an identifier when the image slice is closed |
| casa::ImageSourceFinder< T > | Provides functionality to find sources in an image |
| casacore::ImageStatistics< T > | Displays various statistics from an image |
| casa::ImageStatsCalculator | |
| casacore::ImageSummary< T > | Provides and lists information about the header of an image |
| casa::ImageTask< T > | |
| casa::ImageTracker | Interface class designed to reduce the coupling between the GUI class, ImageManager and the DisplayDataHolder |
| casa::ImageTransposer | |
| casa::ImageTwoPtCorr< T > | Compute two point correlation functions from images |
| casacore::ImageUtilities | Utility functions for Image manipulation |
| casa::ImageView | Displays properties of an image for manipulation such as color and display type |
| casa::Importmiriad | Helper class |
| casa::InActiveDock | Allows the dock widget z-position to be behind the main window instead of the default behavior of always being in front |
| casa::IncCEMemModel | Performs MEM algorithm incrementally |
| casa::IncEntropy | Base class for incremental entropies used by incremental MEM algorithm |
| casa::IncEntropyEmptiness | Emptiness measure for incremental MEM |
| casa::IncEntropyI | Thermodynamic or Information entropy for incremental MEM |
| casacore::IncrementalStMan | The Incremental Storage Manager |
| casacore::indexError< t > | Index errors returning the bad index |
| casacore::IndexError | Base class for all indexing errors |
| casa::dbus::init_diagnostic_object_t | |
| casa::init_dispatcher | |
| casa::pvt::init_qtstringmap | |
| casacore::Input | Input.h: A simple command-line argument method for applications |
| casa::CalAnalysis::INPUT | INPUT nested class (allowed T: CalStats::NONE, CalStatsFitter::FIT, or CalStatsHist::HIST), used to hold the vector output of stats<T>() |
| asdm::Integer | |
| sdmbin::Integration | The class Integration extends the DataDump class by adding an attribute to tag the dump with an integration number |
| casa::InteractiveMasking | |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::InterFractileRangeFunc< T > | |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::InterHexileRangeFunc< T > | |
| casa::viewer::internal_error | |
| casacore::Interpolate1D< Domain, Range > | Interpolate in one dimension |
| casacore::Interpolate2D | A two dimension interpolator for Matrices or Arrays |
| casacore::InterpolateArray1D< Domain, Range > | Interpolate in one dimension |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::InterQuartileRangeFunc< T > | |
| asdm::Interval | Implements an interval of time in units of nanoseconds |
| asdm::InvalidArgumentException | Exception when an attempt is made to access something outside of its defined bounds |
| asdm::InvalidDataException | Exception when an error occurs in converting a numeric value from a string |
| casacore::InvalidIterError | Invalide iteration error class |
| casacore::InvalidSerializationError | |
| casa::InvisibleAxis | |
| casa::functor::invocation_exception | |
| casa::utilj::IoStatistics | |
| casa::IPLatConvEquation | Implements the image plane lattice convolution equation |
| casacore::IPosition | A Vector of integers, for indexing into Array<T> objects |
| casacore::IPosition_global_functions_IPosition_Arithmetic | Arithmetic Operations for IPosition's Element by element arithmetic on IPositions |
| casacore::IPosition_global_functions_IPosition_Indexing | Indexing functions for IPosition's Convert between IPosition and offset in an array |
| casacore::IPosition_global_functions_IPosition_Logical | Logical operations for IPosition's Element by element boolean operations on IPositions |
| casacore::IsFinite< T > | Functor to test for finiteness |
| casacore::IsInf< T > | Functor to test for infinity |
| casacore::ISMBase | Base class of the Incremental Storage Manager |
| casacore::ISMBucket | A bucket in the Incremental Storage Manager |
| casacore::ISMColumn | A Column in the Incremental Storage Manager |
| casacore::ISMIndColumn | A column of Incremental storage manager for indirect arrays |
| casacore::ISMIndex | The Index of the Incremental Storage Manager |
| casacore::IsNaN< T > | Functor to test for NaN |
| casa::QtBorderLayout::ItemWrapper | |
| casa::BorderLayout::ItemWrapper | |
| casa::Iterate | Base class for Iteration |
| casa::vi::IteratingParameters | |
| casa::IterationControl | |
| iterator | |
| casacore::Array< T >::IteratorSTL | |
| casacore::IterBoundaryError | Iteration Boundary error class |
| casacore::IterError | Iteration error class |
| casacore::IterInitError | Iteration initialization error |
| casa::JJones | ********************************************************** JJones |
| casa::Jones | |
| casa::JonesDiag | |
| casa::JonesGenLin | |
| casa::JonesScal | |
| casacore::KaiserBFunction< T > | A one dimensional Kaiser-Bessel function |
| casacore::KaiserBParam< T > | A one dimensional Kaiser-Bessel function |
| casa::KAntPosJones | |
| casacore::KB_Conv< T > | A Kaiser-Bessel function |
| casa::KcrossJones | (sbd) K for cross-hand solve |
| casa::memory::cptr< T >::kernel | |
| casa::viewer::Options::Kernel | |
| casa::dbus::Diagnostic::kernel_t | |
| casa::KJones | Forward declarations |
| casa::KMBDJones | KMBD Jones provides support for multi-band delays |
| casacore::LASTColumn | Local sidereal time derived from TIME, etc |
| casa::LatConvEquation | Implements the convolution equation |
| casacore::Lattice< T > | A templated, abstract base class for array-like objects |
| casacore::LatticeAddNoise | Add noise from specified distribution to a lattice |
| casacore::LatticeApply< T, U > | Optimally iterate through a Lattice and apply provided function object |
| casa::LatticeAsContour< T > | Class to manage the drawing of contour maps of slices from AIPS++ Lattices |
| casa::LatticeAsMarker< T > | Class to manage the drawing of vector maps of slices from AIPS++ Lattices |
| casa::LatticeAsRaster< T > | Class to manage the drawing of raster images of slices from AIPS++ Lattices |
| casa::LatticeAsVector< T > | Class to manage the drawing of vector maps of slices from AIPS++ Lattices |
| casacore::LatticeBase | A non-templated, abstract base class for array-like objects |
| casacore::LatticeCache< T > | Class for caching image access via tiles |
| casacore::LatticeCleaner< T > | A class for doing multi-dimensional cleaning |
| casacore::LatticeCleanProgress | Abstract base class to monitor progress in lattice operations |
| casacore::LatticeConcat< T > | Concatenates lattices along a specified axis |
| casacore::LatticeConvolver< T > | A class for doing multi-dimensional convolution |
| casacore::LatticeExpr< T > | Class to allow C++ expressions involving lattices |
| casacore::LatticeExprNode | Bridging class to allow C++ expressions involving lattices |
| casacore::LatticeFFT | Functions for Fourier transforming Lattices |
| casacore::LatticeFit | Fit every line of pixels parallel to any axis in a Lattice |
| casacore::LatticeFractile< T > | Static functions to get median and fractiles of a lattice |
| casacore::LatticeHistograms< T > | Displays histograms of regions from a lattice |
| LatticeHistograms | |
| casacore::LatticeHistProgress | Provides a progress meter for the LatticeHistograms class |
| casacore::LatticeHistSpecialize | Specialized functions for LatticeHistograms |
| casacore::LatticeIndexer | A helper class for stepping through Lattices |
| casacore::LatticeIterator< T > | A read/write lattice iterator |
| casacore::LatticeIterInterface< T > | A base class for Lattice iterators |
| casacore::LatticeLocker | Class to hold a (user) lock on a lattice |
| casacore::LatticeMathUtil | Static math functions for Lattices |
| casacore::LatticeMathUtil_global_functions_LatticeMathUtil | Global functions on Lattices |
| casa::LatticeModel | Models with an internal & external representation as an Lattice |
| casacore::LatticeNavigator | Abstract base class to steer lattice iterators |
| casa::LatticePADisplayData< T > | Partial implementation of PrincipalAxesDD for Lattice-based data |
| casa::LatticePADisplayMethod< T > | Partial implementation of PrincipalAxesDM for Lattice-based data |
| casa::LatticePADMContour< T > | Class to draw a single contour map of a slice from an AIPS++ Lattice |
| casa::LatticePADMMarker< T > | Class to draw a single vector map of a slice from an AIPS++ Lattice |
| casa::LatticePADMRaster< T > | Class to draw a raster image of a slice of an AIPS++ Lattice |
| casa::LatticePADMVector< T > | Class to draw a single vector map of a slice from an AIPS++ Lattice |
| casacore::LatticeProgress | Abstract base class to monitor progress in lattice operations |
| casacore::LatticeRegion | An optionally strided region in a Lattice |
| casacore::LatticeSlice1D< T > | Extract a 1-D slice from a Lattice |
| casacore::LatticeStatistics< T > | Compute and display various statistics from a lattice |
| casacore::LatticeStatsBase | Base class for LatticeStatistics class |
| casacore::LatticeStatsDataProvider< T > | Data provider which allows stats framework to iterate through an unmasked lattice |
| casacore::LatticeStatsDataProviderBase< T > | Abstract base class of data providers which allows stats framework to iterate through a lattice |
| casacore::LatticeStepper | Traverse a Lattice by cursor shape |
| casacore::LatticeTwoPtCorr< T > | Compute two point auto-correlation functions from a lattice |
| casacore::LatticeUtilities | Static functions for Lattices |
| casacore::LattRegionHolder | Class to hold a region of interest in an image |
| casacore::LattStatsProgress | Provides a progress meter for the LatticeStatistics class |
| casacore::LattStatsSpecialize | |
| casa::vi::LayeredVi2Factory | A factory for generating ViImplementation2 layers that optionally include calibration (via CalibratingVi2) and time-averaging (via AveragingTvi2) |
| casacore::LCBox | Class to define a rectangular box of interest |
| casacore::LCComplement | Make the complement of a region |
| casacore::LCConcatenation | Combine multiple LCRegion's into a new dimension |
| casacore::LCDifference | Make the difference of 2 regions |
| casacore::LCEllipsoid | Define an N-dimensional ellipsoidal region of interest |
| casacore::LCExtension | Extend an LCRegion along straight lines to other dimensions |
| casacore::LCHDF5Mask | Class to define a rectangular mask as a region |
| casacore::LCIntersection | Make the intersection of 2 or more regions |
| casacore::LCLELMask | Class to define a mask as a LEL expression |
| casacore::LCMask | Class to define a rectangular mask as a temporary region |
| casacore::LCPagedMask | Class to define a rectangular mask as a region |
| casacore::LCPixelSet | Class to define a rectangular mask as a region |
| casacore::LCPolygon | Define a 2-dimensional region by a polygon |
| casacore::LCRegion | Abstract base class to define a region of interest in lattice coordinates |
| casacore::LCRegionFixed | Abstract base class to define a fixed region |
| casacore::LCRegionMulti | Make the intersection of 2 or more regions |
| casacore::LCRegionSingle | Abstract base class to define a single region |
| casacore::LCSlicer | Class to define a rectangular box of interest with strides |
| casacore::LCStretch | Stretch length 1 axes in an LCRegion along straight lines |
| casacore::LCUnion | Make the union of 2 or more regions |
| casacore::LECanonicalConversion | A class with static functions to convert little endian canonical format |
| casacore::LECanonicalDataConversion | A class with virtual functions to convert little endian canonical format |
| casacore::LECanonicalIO | Class for IO in little endian canonical format |
| casa::LegendCurve | Custom QwtPlotCurve that provides the capability of a thicker (rectangular) legend rather than a hard-to-see line that mirrors the thickness of the curve |
| casa::LegendItemRect | Custom QwtLegendItem that draws a rectangular legend symbol in a color matching the curve |
| casa::LegendPreferences | Allows the user to customize properties of the spectral profile legend |
| casacore::LELArray< T > | This LEL class holds an array with a mask |
| casacore::LELArrayBase | Base class for LELArray holding the mask |
| casacore::LELArrayRef< T > | This LEL class holds a possible referenced array with a mask |
| casacore::LELAttribute | Ancillary information for the LEL letter classes |
| casacore::LELBinary< T > | This LEL class handles numerical binary operators |
| casacore::LELBinaryBool | This LEL class handles logical binary operators |
| casacore::LELBinaryCmp< T > | This LEL class handles relational binary numerical operators |
| casacore::LELBinaryEnums | Each LEL binary operation is described in this enum |
| casacore::LELCondition< T > | Class to make a mask from a condition |
| casacore::LELConvert< T, F > | Class to convert a LEL node from one numerical type to another |
| casacore::LELCoordinates | Envelope class to handle Lattice Coordinates in LEL |
| casacore::LELFunction1D< T > | This LEL class handles numerical (real and complex) 1-argument functions |
| casacore::LELFunctionBool | This LEL class handles logical functions |
| casacore::LELFunctionComplex | This LEL class handles complex numerical functions |
| casacore::LELFunctionDComplex | This LEL class handles double complex numerical functions |
| casacore::LELFunctionDouble | This LEL class handles numerical functions whose return type is a Double |
| casacore::LELFunctionEnums | Each LEL function is described in this enum |
| casacore::LELFunctionFloat | This LEL class handles numerical functions whose return type is a Float |
| casacore::LELFunctionND< T > | This LEL class handles functions with a variable number of arguments |
| casacore::LELFunctionReal1D< T > | This LEL class handles numerical (real only) 1-argument functions |
| casacore::LELImageCoord | The letter class for image coordinates |
| casacore::LELInterface< T > | This base class provides the interface for Lattice expressions |
| casacore::LELLattCoord | The base letter class for lattice coordinates in LEL |
| casacore::LELLattCoordBase | The base letter class for lattice coordinates in LEL |
| casacore::LELLattice< T > | This LEL class handles access to Lattices |
| casacore::LELRegion | Class to hold a region as a LEL node |
| casacore::LELRegionAsBool | Class to convert a region to a boolean node |
| casacore::LELScalar< T > | This LEL class holds a scalar with a mask |
| casacore::LELSpectralIndex< T > | This LEL class handles calculation of the spectral index |
| casacore::LELUnary< T > | This LEL class handles numerical unary operators |
| casacore::LELUnaryBool | This LEL class handles logical unary operators |
| casacore::LELUnaryConst< T > | This LEL class handles scalar (unary) constants |
| casacore::LELUnaryEnums | Each LEL unary operation is described in this enum |
| asdm::Length | Implements a quantity of length in meters |
| casa::LimbDarkenedDiskShape | A limb-darkened disk model for the spatial distribution of emission |
| casacore::LinearCoordinate | Interconvert between pixel and a linear world coordinate |
| casa::LinearEquation< Domain, Range > | Defines a relationship between Domain and Range objects |
| casacore::LinearFit< T > | Class for linear least-squares fit |
| casacore::LinearFitSVD< T > | Linear least-squares fit using Singular Value Decomposition method |
| casa::LinearModel< Domain > | Provides a model for use in model fitting applications |
| casa::LinearMosaic | Class that contains functions needed for feathering |
| casacore::LinearSearch_global_functions_linearsearch | Linear search a linear data structure |
| casacore::LinearXform | Perform a linear transform between input and output vectors |
| casacore::LineCollapser< T, U > | Abstract base class for LatticeApply function signatures |
| casa::LineFinderParameter | |
| casa::LineFinderUtils | |
| casa::LineOverlaysSearchResultsDialog | |
| casa::LineOverlaysTab | |
| casacore::Link< t > | Doubly linked list primitive |
| casa::LinkedCursorEH | |
| casacore::List< t > | Doubly linked list |
| casa::ListConverter | Converts a list or lists dumped from the splatalogue web interface to a casa table |
| casacore::ListIO_global_functions_List_IO | Input/output operators for Lists |
| casacore::ListIter< t > | Doubly linked non-constant list iterator The List class above only provides for the list framework |
| casacore::ListNotice< t > | Linked list update notice |
| casacore::LittleEndianConversion | A class with static functions to convert littleEndian format |
| casa::LJJones | ********************************************************** LJJones (pointing errors) |
| casacore::LockFile | Class to handle file locking and synchronization |
| casa::async::LockGuard | |
| casa::async::LockGuardInverse | |
| casacore::Log< T, RES > | Functor to apply log |
| casacore::Log10< T, RES > | Functor to apply log10 |
| casa::LogFile | |
| casacore::LogFilter | Filter LogMessages on message priority |
| casacore::LogFilterExpr | Class to deal with a TaQL expression to filter messages |
| casacore::LogFilterInterface | Abstract base class for filtering LogMessages |
| casa::LogFilterParallel | |
| casacore::LogFilterTaql | Filter LogMessages using a TaQL expression |
| casa::async::Logger | |
| casacore::LoggerHolder | Class holding a hierarchy of loggers |
| casacore::LoggerHolderIterator | Class to iterate through an LoggerHolder |
| casacore::LoggerHolderRep | Representation of the class holding a hierarchy of loggers |
| casa::async::Logger::LoggerThread | |
| casacore::LogHolderIter | Class doing the actual iteration through an LoggerHolder |
| casacore::LogHolderIterEntry | Class representing an entry in a LoggerHolder |
| casacore::LogiArray_global_functions_LogicalArray | Logical valued Arrays |
| casacore::LogiArrayFwd_global_functions_LogicalArray_forwards | Forward declarations for LogicalArrays |
| casa::vi::LogicalANDKernel | |
| casacore::LogiCube_global_functions_LogicalCube | Logical valued Cubes |
| casacore::LogiMatrix_global_functions_LogicalMatrix | Logical valued Matrices |
| casacore::LogIO | Ostream-like interface to creating log messages |
| casacore::LogIO_global_functions_command | Functions to send commands to a LogIO object |
| casacore::LogIO_global_functions_output | Functions to accumulate text in the output message |
| casa::LogItem | |
| casacore::LogiVector_global_functions_LogicalVector | Logical valued Vectors |
| casacore::LogMessage | Informational log messages with with time, priority, and origin |
| casacore::LogMessage_global_functions_LogMessage_ostream | Write a LogMessage to an ostream |
| casa::LogModel | |
| casacore::LogNormal | Logarithmic normal distribution |
| casacore::LogOrigin | LogOrigin: The source code location of the originator of a LogMessage |
| casacore::LogOrigin_global_functions_LogOrigin_ostream | Write a LogOrigin to an ostream |
| casacore::LogOrigin_global_functions_SourceLocation | Helper struct to get the source line |
| casacore::LogSink | Distribute LogMessages to their destination(s) |
| casacore::LogSinkInterface | Accepts LogMessages and posts them to some destination |
| casa::LogTransformedPolynomialSpectralElement | Describes the often used for determining spectral index plus higher order terms: y = log (S_x) = ln(c_0) + c_1*ln(x) + c_2*ln(x)**2 + c_3*ln(x)**3 + ..\. where c_1 is the traditional spectral index (alpha) |
| casa::LogViewer | |
| asdm::Long | A collection of static methods to perform conversions between strings and int64_t values |
| casacore::Lorentzian1D< T > | A one dimensional Lorentzian class |
| casacore::Lorentzian1D_PS< AutoDiff< T > > | Partial specialization of Lorentzian1D for AutoDiff |
| casacore::Lorentzian1DParam< T > | Parameter handling for one dimensional Lorentzian class |
| casa::LorentzianSpectralElement | Describes a single Lorentzian spectral profile |
| casacore::LogSink::LsiIntermediate | LsiIntermediate is a helper class to allow LogSinkInterface to implement semantics that allow causing all classes accessing the log sink to be aimed at a different sink object |
| casacore::LSQaips | Interface for Casacore Vectors in least squares fitting |
| casacore::LSQComplex | Type of complex numeric class indicator |
| casacore::LSQFit | Basic class for the least squares fitting |
| casacore::LSQMatrix | Support class for the LSQ package |
| casacore::LSQNull | Non relevant class indicator |
| casacore::LSQReal | Typing support classes for LSQ classes |
| casacore::LSQTraits< T > | Traits for numeric classes used |
| casacore::LSQTraits_CD< std::complex< Double > > | LSQTraits specialization for DComplex |
| casacore::LSQTraits_CF< std::complex< Float > > | LSQTraits specialization for Complex |
| casacore::LSQTraits_D< Double > | LSQTraits specialization for Double |
| casacore::LSQTraits_F< Float > | LSQTraits specialization for Float |
| casacore::LSQType< T > | Determine if pointer type |
| LUdecomp< T > | On suns, at least, this needs to link with: lapack.a blas.a Since this links fortran libraries, check also whether "underscores" are needed for FORTRAN on your machine, and whether a FORTRAN MAIN is needed to initialize the fortran libraries (as it is on suns) |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::MadfmFunc< T > | |
| asdm::MainRow | Row of a MainTable |
| asdm::MainTable | Alma table |
| casa::MakeApproxPSFAlgorithm | Parallelized version of approximate PSF formation |
| casacore::MakeComplex< L, R, RES > | Functor to form a complex number from the left and right value |
| casacore::MakeComplexImag< L, R, RES > | Functor to form a complex number from the left value and the imaginary part of the right value |
| casacore::MakeComplexReal< L, R, RES > | Functor to form a complex number from the real part of the left value and the right value |
| casacore::MakeComplexRealImag< L, R, RES > | Functor to form a complex number from the real part of the left value and the imaginary part of the right value |
| casa::MakeMask | |
| casa::MakeRegion | |
| casacore::MArrayLogical_global_functions_MArray_logical_operations::MAllFunc< T > | |
| mallinfo | |
| casacore::MArrayLogical_global_functions_MArray_logical_operations::MAnyFunc< T > | |
| casacore::Map< key, value > | Abstract base class for associative arrays |
| casacore::MapIO_global_functions_Map_IO | Input/output operators for Maps |
| casacore::MapIter< key, value > | Associative array iterator |
| casacore::MapIterRep< key, value > | Abstract base class for associative array iterators |
| casacore::MappedArrayEngine< VirtualType, StoredType > | Templated virtual column engine to map the data type of a table array |
| casacore::MapRep< key, value > | Map representation class |
| Marker | |
| casacore::MArray< T > | Class to handle an Array with an optional mask |
| casacore::MArrayBase | Base class for an array with an optional mask |
| casacore::MArrayMathBase_global_functions_Array_basic_functions::MArrayFunctorBase< T, RES > | Define the base class for functors to perform a reduction function on an MArray object |
| casacore::MArrayLogical_global_functions_MArray_logical_operations | Logical operations for MArray objects |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations | Mathematical operations for MArray objects |
| casacore::MArrayMathBase_global_functions_Array_basic_functions | Basic functions and classes for math on MArray objects |
| casacore::MArrayUtil_global_functions_reorderMArray | Reorder the axes of the data in an MArray object |
| casacore::MarshallableChebyshev< T > | A Chebyshev function class that supports serialization |
| casacore::MarshButterworthBandpass< T > | A Butterworth function class that supports serialization |
| casacore::MaskArrIO_global_functions_MaskedArray_IO | Ascii input/output operations for MaskedArrays |
| casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations | Logical operations for MaskedArrays, and between MaskedArrays and Arrays |
| casacore::MaskArrMath_global_functions_MaskedArray_mathematical_operations | Mathematical operations for MaskedArrays (and with Arrays) |
| casacore::MaskedArray< T > | Class for masking an Array for operations on that Array |
| casacore::MaskedArray_global_functions_MaskedArray_general_global_functions | General global functions for MaskedArrays, and MaskedArrays and Arrays |
| casa::MaskedArrayModel< T > | Base class for models with an internal & external representation as a MaskedArray |
| casacore::MaskedAvdevFunc< T > | |
| casa::MaskedHogbomCleanModel< T > | A Class for performing Hogbom Clean's of Arrays |
| casacore::MaskedLattice< T > | A templated, abstract base class for array-like objects with masks |
| casacore::MaskedLatticeStatsDataProvider< T > | Data provider which allows stats framework to iterate through a masked lattice |
| casacore::MaskedMadfmFunc< T > | |
| casacore::MaskedMaxFunc< T > | |
| casacore::MaskedMeanFunc< T > | |
| casacore::MaskedMedianFunc< T > | |
| casacore::MaskedMinFunc< T > | |
| casacore::MaskedProductFunc< T > | |
| casacore::MaskedRmsFunc< T > | |
| casa::MaskedScatterPlot | Subclass of ScatterPlot that adds masking functionality |
| casacore::MaskedStddevFunc< T > | |
| casacore::MaskedSumFunc< T > | |
| casacore::MaskedVarianceFunc< T > | |
| casacore::MaskLogiArr_global_functions_MaskedLogicalArray | Masked LogicalArrays |
| casacore::MaskLogiArrFwd_global_functions_MaskedLogicalArray_forwards | Forward declarations for MaskedLogicalArrays |
| casacore::MaskSpecifier | Class to specify which mask to use in an image |
| casacore::Math_global_functions_Math_interface_for_casacore | Casacore interface to math.h and other scalar math functions |
| casacore::MathFunc< T > | A class to generate values of mathematical functions |
| casacore::MathFunc_global_functions_FUNCTYPE_enum | Enum used to identify function type for MathFunc class |
| casacore::MathFunc_global_functions_spheriodal_functions | Fred Schwab function to calculate spheriodal functions |
| casacore::MathFuncError | Error class for MathFunc class |
| casacore::Matrix< T > | A 2-D Specialization of the Array class |
| casa::MatrixCleaner | A copy of LatticeCleaner but just using 2-D matrices |
| casacore::MatrixIterator< T > | Iterate a Matrix cursor through another Array |
| casacore::MatrixMath_global_functions_Linear_Algebra | Linear algebra functions on Vectors and Matrices |
| casacore::MatrixMathLA_global_functions_Linear_Algebra | Linear algebra functions on Vectors and Matrices |
| casa::MatrixNACleaner | A simple deconvolver that masks by memory of previous peaks |
| casacore::MatrixSolver | MatrixSolver.h: the base class for solvers of linear equations AX=B |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MAvdevFunc< T > | |
| casacore::Max< L, R, RES > | Functor to get maximum of two values |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::MaxFunc< T > | |
| casacore::MBaseline | A Measure: Baseline on Earth |
| casacore::MCBase | Base for specific measure conversions |
| casacore::MCBaseline | MBaseline conversion routines |
| casacore::MCDirection | MDirection conversion routines |
| casacore::MCDoppler | MDoppler conversion routines |
| casacore::MCEarthMagnetic | MEarthMagnetic conversion routines |
| casacore::MCEpoch | MEpoch conversion routines |
| casacore::MCFrame | Measure frame calculations proxy |
| casacore::MCFrequency | MFrequency conversion routines |
| casacore::MConvertBase | Conversion of Measures Base |
| casacore::MConvertBase_global_functions_Output | Global functions |
| casacore::MCPosition | MPosition conversion routines |
| casacore::MCRadialVelocity | MRadialVelocity conversion routines |
| casacore::MCuvw | Muvw conversion routines |
| casacore::MDirection | A Measure: astronomical direction |
| casacore::MDoppler | A Measure: Doppler shift |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::MeanFunc< T > | |
| casacore::MEarthMagnetic | A Measure: Magnetic field on Earth |
| casacore::MeasBase< Mv, Mr > | Base class for all measures |
| casacore::MeasComet | Position for comets and other solar system bodies |
| casacore::MeasConvert< M > | Conversion of Measures |
| casacore::MeasData | MeasData provides Measure computing data |
| casacore::MeasFrame | Container for Measure frame |
| casacore::MeasFrame_global_functions_Output | Global functions |
| casacore::MeasIERS | Interface to IERS tables |
| casacore::MeasJPL | Interface to JPL DE tables |
| casacore::MeasMath | Measure conversion aid routines |
| casacore::MeasRef< Ms > | Reference frame for physical measures |
| casacore::MeasTable | MeasTable provides Measure computing database data |
| casacore::MeasTableMul | MeasTableMul provides thread-safe access to time-dependent multiplier matrices |
| casacore::MeasTableMulAber | Class calculating the standard aberration multipliers |
| casacore::MeasTableMulAber1950 | Class calculating the B1950 aberration multipliers |
| casacore::MeasTableMulPosEarthXY | Class calculating the XY earth position multipliers |
| casacore::MeasTableMulPosEarthZ | Class calculating the Z earth position multipliers |
| casacore::MeasTableMulPosSunXY | Class calculating the XY solar position multipliers |
| casacore::MeasTableMulPosSunZ | Class calculating the Z solar position multipliers |
| casacore::MeasTableMulSC | Class calculating the standard nutation multipliers |
| casacore::MeasTableMulSC1950 | Class calculating the B1950 nutation multipliers |
| casacore::MeasTableMulSC2000A | Class calculating the J2000A nutation multipliers |
| casacore::MeasTableMulSC2000B | Class calculating the J2000B nutation multipliers |
| casacore::MeasTableMulSC2000Base | Base class for J2000 nutation multipliers |
| casacore::MeasTableMulSCBase | Base class for standard and B1950 nutation multipliers |
| casacore::Measure | Physical quantities within reference frame |
| casacore::Measure_global_functions_Output | Global functions |
| casacore::MeasureHolder | A holder for Measures to enable record conversions |
| casacore::MeasurementSet | A Table intended to hold astronomical data (a set of Measurements) |
| casa::MeasurementSet2 | |
| casa::VisibilityIteratorReadImpl::MeasurementSetChannels | |
| casacore::MeasuresProxy | |
| casacore::MeasValue | Base class for values in a Measure |
| casacore::MeasValue_global_functions_Output | Global functions |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::MedianFunc< T > | |
| casacore::MedianSlider | Class to compute sliding median |
| casacore::Memory | Memory related information and utilities. use visibility=export> |
| casacore::MemoryIO | Class for IO to a memory buffer |
| casacore::MemoryLogSink | Save log messages in memory |
| casa::utilj::MemoryStatistics | |
| casacore::MemoryStMan | Memory-based table storage manager class |
| casacore::MemoryTable | Class for a table held in memory |
| casacore::MemoryTrace | Memory usage tracing mechanism |
| casacore::MemoryTraceBlock | Class to write begin and end block message |
| casacore::MEpoch | A Measure: instant in time |
| asdm::Merger | |
| casacore::Casarc::meta_entry_ | |
| casa::MFCEMemImageSkyModel | MF CE Mem Image Sky Model: Image Sky Model implementing the MF Mem algorithm |
| casa::MFCleanImageSkyModel | MF Image Sky Model: Image Sky Model implementing the MF Clean algorithm |
| casacore::MFFileIO | Class for IO on a virtual file in a MultiFileBase |
| casa::MFMSCleanImageSkyModel | Image Sky Model implementing the MultiScale, MultiField Clean algorithm |
| casa::MfMueller | ********************************************************** MfMueller (freq-dep MMueller) |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MFractileFunc< T > | |
| casacore::MFrequency | A Measure: wave characteristics |
| casa::MIfrDesc | MIfrDesc: Define the format of MIfr cal tables |
| casa::MIfrMRec | MIfrMRec: MIfr cal_main table record access & creation |
| casacore::Min< L, R, RES > | Functor to get minimum of two values |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::MinFunc< T > | |
| casacore::Minus< L, R, RES > | Functor to subtract variables of possibly different types |
| MirDataBuffer | Buffer for data read in from a Miriad datatset |
| MirDataRecord | Container for a data record read in from a Miriad datatset |
| MirField | Container for field information |
| mirfiller | A Distributed Object for filling MIRIAD uv data into an MS |
| MirFiller | BIMA MIRIAD dataset to MeasurementSet2 filler |
| MirFreqSetup | A description of a Miriad spectroscopy (correlator) setup |
| MirHisReader | Miriad history reader |
| MiriadFormatError | Exception indicating that a non-recoverable format error was detected in the input Miriad dataset |
| casacore::MIRIADImage | Class providing native access to MIRIAD images |
| MiriadMemoryAssumptionError | Exception indicating that assumptions about the size of primitive types are not satisfied |
| MiriadUnsupportedFeatureError | Exception indicating that further processing is dependent on an unsupported feature of a Miriad dataset |
| MirInfo | Abstract base for classes that contain information about some part of a Miriad Dataset |
| MirPolCorr | Container for a single Miriad polarization correlation |
| MirPolRecps | Container for a set of Miriad (single-) polarization receptor types |
| MirPolSetup | Editable container for a set of Miriad polarization correlation types |
| MirSource | Container for source information |
| MirTypeAssert | Base for classes that rely on assumptions regarding privitive type sizes |
| MirVarHandler | |
| MirVisReader | Miriad visibility dataset reader |
| casa::MJonesDesc | MJonesDesc: Define the format of MJones calibration tables |
| casa::MJonesMRec | MJonesMRec: MJones cal_main table record access and creation |
| casacore::MLCG | Multiplicative linear congruential generator |
| casacore::MMapfdIO | Memory-mapped IO on a file |
| casacore::MMapIO | Memory-mapped IO on a file |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MMaxFunc< T > | |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MMeanFunc< T > | |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MMedianFunc< T > | |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MMinFunc< T > | |
| casa::MMueller | ********************************************************** M: baseline-based (closure) |
| casacore::MArrayLogical_global_functions_MArray_logical_operations::MNFalseFunc< T, RES > | |
| casacore::MArrayLogical_global_functions_MArray_logical_operations::MNTrueFunc< T, RES > | Define functors to perform a reduction function on an MArray object |
| casacore::Mod_KB_Conv< T > | A Kaiser-Bessel function multiplied by a Gaussian |
| casacore::ModcompConversion | Static functions to convert Modcomp numeric formats |
| casacore::ModcompDataConversion | A DataConversion class to convert between Modcomp format |
| casacore::Modulo< L, R, RES > | Functor to take modulo of (integer) variables of possibly different types in the C way |
| casa::MolecularLine | |
| casa::MomentCalcBase< T > | Abstract base class for moment calculator classes |
| casa::MomentClip< T > | Computes simple clipped, and masked moments |
| casa::MomentCollapseThreadRadio | Note: ImageMomentsProgressMonitor is an interface that provides this class with updates concerning the progress of the moment calculation task |
| casa::MomentFit< T > | Compute moments from a Gaussian fitted to a profile |
| casa::MomentsBase< T > | This class is a base class for generating moments from an image or a spectral data |
| casa::MomentSettingsWidgetOptical | |
| casa::MomentSettingsWidgetRadio | Note: ProfileTaskFacilitator abstracts out some of the common functionality needed for calculating moments and spectral line fitting into a single base class |
| casa::MomentWindow< T > | Computes moments from a windowed profile |
| casa::MosaicFT | |
| casa::refim::MosaicFT | |
| casa::MosaicFTNew | |
| casa::refim::MosaicFTNew | |
| casa::MPIError | Base error class for MPI |
| casacore::MPosition | A Measure: position on Earth |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MProductFunc< T > | |
| casacore::MRadialVelocity | A Measure: radial velocity |
| casacore::MRBase | Base for Reference frame for physical measures |
| casacore::MRBase_global_functions_Output | Global functions |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MRmsFunc< T > | |
| casacore::MrsEligibility | |
| casacore::MS1ToMS2Converter | Class to convert a MeasurementSet v1 to v2 |
| casa::MS2ASDM | MS2ASDM provides functionalities to create an ASDM (ALMA science data model) from an existing MS |
| casa::viewer::qt::ms_stats_t | |
| casacore::MSAntenna | A Table intended to hold a MeasurementSet ANTENNA table |
| casacore::MSAntennaColumns | A class to provide easy read-write access to MSAntenna columns |
| casacore::MSAntennaEnums | Enums for the MeasurementSet ANTENNA table |
| casacore::MSAntennaGram_global_functions_MSAntennaGramFunctions | Global functions for flex/bison scanner/parser for MSAntennaGram |
| casacore::MSAntennaIndex | Class to handle lookup or indexing into a MS ANTENNA subtable |
| casacore::MSAntennaParse | Class to hold values from antenna grammar parser |
| casacore::MSArrayGram_global_functions_MSArrayGramFunctions | Global functions for flex/bison scanner/parser for MSArrayGram |
| casacore::MSArrayParse | Class to hold values from array grammar parser |
| casa::MSAsRaster | Class for displaying data within an MS as a raster (gridded) image |
| casa::MSAsRasterDM | (Minimal) DisplayMethod for MSAsRaster |
| casa::MsAverager | |
| casa::MSCache | |
| casa::MSCacheVolMeter | |
| casacore::MSCalEngine | Engine to calculate derived MS values |
| casa::MSCalEnums | |
| casa::MSCalPatchKey | |
| casa::MSChecker | Putting checks here, since Ger objected to them going in casacore |
| casa::MSCleanImageSkyModel | MS Clean Image Sky Model: Image Sky Model implementing the MS Clean algorithm |
| casacore::MSColumns | A class to provide easy read-write access to MeasurementSet columns |
| casacore::MSConcat | A class with functions for concatenating MeasurementSets |
| casa::MSContinuumSubtractor | Fits and subtracts or models the continuum in spectra |
| casacore::MSCorrGram_global_functions_MSCorrGramFunctions | Global functions for flex/bison scanner/parser for MSCorrGram |
| casacore::MSCorrParse | Class to hold values from UV dist grammar parser |
| sdmbin::MSData | A structure containing a block of data for a single MS Main table row |
| casacore::MSDataDescColumns | A class to provide easy read-write access to MSDataDescription columns |
| casacore::MSDataDescIndex | Class to handle lookup or indexing into a MS DATA_DESC subtable |
| casacore::MSDataDescription | A Table intended to hold a MeasurementSet DATADESCRIPTION table |
| casacore::MSDataDescriptionEnums | Enums for the MeasurementSet DATA_DESCRIPTION table |
| casa::sdfiller::MSDataRecord | |
| casacore::MSDerivedValues | MSDerivedValues calculates values derived from a MS |
| casacore::MSDoppler | A Table intended to hold a MeasurementSet DOPPLER table |
| casacore::MSDopplerColumns | A class to provide easy read-write access to MSDoppler columns |
| casacore::MSDopplerEnums | Enums for the MeasurementSet DOPPLER table |
| casacore::MSDopplerIndex | |
| casacore::MSDopplerUtil | A utility class for MS Doppler tracking information |
| casacore::MSFeed | A Table intended to hold a MeasurementSet FEED table |
| casacore::MSFeedColumns | A class to provide easy read-write access to MSFeed columns |
| casacore::MSFeedEnums | Enums for the MeasurementSet FEED table |
| casacore::MSFeedGram_global_functions_MSFeedGramFunctions | Global functions for flex/bison scanner/parser for MSFeedGram |
| casacore::MSFeedIndex | |
| casacore::MSFeedParse | Class to hold values from feed grammar parser |
| casacore::MSField | A Table intended to hold a MeasurementSet FIELD table |
| casacore::MSFieldColumns | A class to provide easy read-write access to MSField columns |
| casacore::MSFieldEnums | Enums for the MeasurementSet FIELD table |
| casacore::MSFieldGram_global_functions_MSFieldGramFunctions | Global functions for flex/bison scanner/parser for MSFieldGram |
| casacore::MSFieldIndex | Class to handle lookup or indexing into a MS FIELD subtable |
| casacore::MSFieldParse | Class to hold values from field grammar parser |
| casacore::MSFitsIDI | MSFitsIDI: Convert FITS-IDI data to MS format |
| casacore::MSFitsInput | UV FITS to MeasurementSet filler |
| casacore::MSFitsOutput | Write a MeasurementSet to a random group uvfits file |
| casacore::MSFitsOutputAstron | Write a MeasurementSet to a random group uvfits file |
| casacore::MSFlagCmd | A Table intended to hold a MeasurementSet FLAG_CMD table |
| casacore::MSFlagCmdColumns | A class to provide easy read-write access to MSFlagCmd columns |
| casacore::MSFlagCmdEnums | Enums for the MeasurementSet FLAG_CMD table |
| casacore::MSFlagger | MSFlagger specifies selections on a MeasurementSet |
| casacore::MSFreqOffIndex | |
| casacore::MSFreqOffset | A Table intended to hold a MeasurementSet FREQ_OFFSET table |
| casacore::MSFreqOffsetColumns | A class to provide easy read-write access to MSFreqOffset columns |
| casacore::MSFreqOffsetEnums | Enums for the MeasurementSet FREQ_OFFSET table |
| casacore::MSHistory | A Table intended to hold a MeasurementSet OBSERVATIONLOG table |
| casacore::MSHistoryColumns | A class to provide easy read-write access to MSHistory columns |
| casacore::MSHistoryEnums | Enums for the MeasurementSet HISTORY table |
| casacore::MSHistoryHandler | A class to provide a simple interface to history writing |
| casacore::MSInterface | MSInterface: A specialization of MSSelectableTable for accessing MS |
| casacore::MSInterval | Small helper class to specify an 'interval' comparison |
| casacore::MSIter | An iterator class for MeasurementSets |
| casa::vi::MsIterInfo | |
| casacore::MSLister | List visibility records from a Measurement Set |
| casacore::MSMainColInterface | |
| casacore::MSMainColumns | A class for easy read-write access to MeasurementSet main table columns |
| casacore::MSMainEnums | Enums for the MeasurementSet main table |
| casacore::MSMBase | Base class for memory-based table storage manager class |
| casacore::MSMColumn | Column in the Memory table storage manager class |
| casacore::MSMDirColumn | Memory storage manager for table arrays |
| casacore::MSMetaData | Class to interrogate an MS for metadata. Interrogation happens on demand and resulting metadata are stored for use by subsequent queries if the cache has not exceeded the specified limit. Parallel processing is enabled using openmp |
| casa::MSMetaInfoForCal | |
| casacore::MSMIndColumn | Mmeory storage manager for variable shaped table arrays |
| casacore::MSObservation | A Table intended to hold a MeasurementSet OBSERVATION table |
| casacore::MSObservationColumns | A class to provide easy read-write access to MSObservation columns |
| casacore::MSObservationEnums | Enums for the MeasurementSet OBSERVATION table |
| casacore::MSObservationGram_global_functions_MSObservationGramFunctions | Global functions for flex/bison scanner/parser for MSObservationGram |
| casacore::MSObservationIndex | Class to handle lookup or indexing into an MS OBSERVATION subtable |
| casacore::MSObservationParse | Class to hold values from scan grammar parser |
| casacore::MSParse | Class to hold values from an ms grammar parser |
| casacore::MSPointing | A Table intended to hold a MeasurementSet POINTING table |
| casacore::MSPointingColumns | A class to provide easy read-write access to MSPointing columns |
| casacore::MSPointingEnums | Enums for the MeasurementSet POINTING table |
| casacore::MSPointingIndex | |
| casacore::MSPolarization | A Table intended to hold a MeasurementSet POLARIZATION table |
| casacore::MSPolarizationColumns | A class to provide easy read-write access to MSPolarization columns |
| casacore::MSPolarizationEnums | Enums for the MeasurementSet POLARIZATION table |
| casacore::MSPolarizationIndex | Class to handle lookup or indexing into an MS POLARIZATION subtable |
| casacore::MSPolnGram_global_functions_MSPolnGramFunctions | Global functions to drive the MSPolnParse class. These, for Polarization selection, need not be global functions, but are done this way to keep the interface uniform for the various selection expressions |
| casacore::MSPolnParse | Class to hold values from field grammar parser |
| casa::MSAsRaster::MSpos_ | |
| casacore::MSPrimaryGroupHolder | A helper class for MSFitsInput |
| casacore::MSPrimaryTableHolder | A helper class for MSFitsInput |
| casacore::MSProcessor | A Table intended to hold a MeasurementSet PROCESSOR table |
| casacore::MSProcessorColumns | A class to provide easy read-write access to MSProcessor columns |
| casacore::MSProcessorEnums | Enums for the MeasurementSet PROCESSER table |
| casacore::MSRange | MSRange determines ranges of values in a MeasurementSet |
| casacore::MSReader | Read from an MS, coordinating all of the subtables in the process |
| casa::viewer::MsRegionInfo | |
| casa::ms::MsRow | Class MsRowAttributes { |
| casa::ms::MsRows | |
| casacore::MSScanGram_global_functions_MSScanGramFunctions | Global functions for flex/bison scanner/parser for MSScanGram |
| casacore::MSScanParse | Class to hold values from scan grammar parser |
| casacore::MSSelectableMainColumn | |
| casacore::MSSelectableTable | MSSelectableTable: An interface class used by MSSelection module to access the sub-tables and main-table columns of MS-like tables |
| casacore::MSSelection | MSSelection: Class to represent a selection on an MS |
| casacore::MSSelectionAntennaError | ------------------------------------------------------------------- |
| casacore::MSSelectionAntennaParseError | ------------------------------------------------------------------- |
| casacore::MSSelectionArrayError | ------------------------------------------------------------------- |
| casacore::MSSelectionArrayParseError | |
| casacore::MSSelectionArrayWarning | |
| casacore::MSSelectionError | |
| casacore::MSSelectionErrorHandler | |
| casacore::MSSelectionFeedError | ------------------------------------------------------------------- |
| casacore::MSSelectionFeedParseError | |
| casacore::MSSelectionFieldError | ------------------------------------------------------------------- |
| casacore::MSSelectionFieldParseError | ------------------------------------------------------------------- |
| casacore::MSSelectionFieldWarning | ------------------------------------------------------------------- |
| casacore::MSSelectionKeywords | MSSelectionKeywords specifies selection keywords for the MeasurementSet |
| casacore::MSSelectionLogError | |
| casacore::MSSelectionNullExpr | ------------------------------------------------------------------- |
| casacore::MSSelectionNullSelection | ------------------------------------------------------------------- |
| casacore::MSSelectionNullTEN | ------------------------------------------------------------------- |
| casacore::MSSelectionObservationError | ------------------------------------------------------------------- |
| casacore::MSSelectionObservationParseError | |
| casacore::MSSelectionObservationWarning | |
| casacore::MSSelectionPolnError | ------------------------------------------------------------------- |
| casacore::MSSelectionPolnParseError | |
| casacore::MSSelectionPolnWarning | |
| casacore::MSSelectionScanError | ------------------------------------------------------------------- |
| casacore::MSSelectionScanParseError | |
| casacore::MSSelectionScanWarning | |
| casacore::MSSelectionSpwError | ------------------------------------------------------------------- |
| casacore::MSSelectionSpwParseError | |
| casacore::MSSelectionSpwWarning | |
| casacore::MSSelectionStateError | ------------------------------------------------------------------- |
| casacore::MSSelectionStateParseError | |
| casacore::MSSelectionStateWarning | |
| casacore::MSSelectionTimeError | ------------------------------------------------------------------- |
| casacore::MSSelectionTimeParseError | |
| casacore::MSSelectionUvDistError | ------------------------------------------------------------------- |
| casacore::MSSelectionUvDistParseError | |
| casacore::MSSelector | MSSelector specifies selections on a MeasurementSet |
| casacore::MSSelUtil< T > | Helper class for MSFlagger with templated static function |
| casacore::MSSelUtil2< T > | |
| casacore::MSSource | A Table intended to hold a MeasurementSet SOURCE table |
| casacore::MSSourceColumns | A class to provide easy read-write access to MSSource columns |
| casacore::MSSourceEnums | Enums for the MeasurementSet SOURCE table |
| casacore::MSSourceIndex | |
| casacore::MSSpectralWindow | A Table intended to hold a MeasurementSet SPECTRAL_WINDOW table |
| casacore::MSSpectralWindowEnums | Enums for the MeasurementSet SPECTRAL_WINDOW table |
| casacore::MSSpwGram_global_functions_MSSpwGramFunctions | Global functions for flex/bison scanner/parser for MSSpwGram |
| casacore::MSSpwIndex | Class to handle lookup or indexing into a MS Data_Desc_ID and SpectralWindow subtables |
| casacore::MSSpWindowColumns | A class to provide easy read-write access to MSSpectralWindow columns |
| casacore::MSSpWindowIndex | Class to handle lookup or indexing into a MS SPECTRAL_WINDOW subtable |
| casacore::MSSpwParse | Class to hold values from field grammar parser |
| casacore::MSSSpwErrorHandler | |
| sdmbin::MSState | A structure containing state information following the MSv2.0 data model |
| casacore::MSState | A Table intended to hold a MeasurementSet STATE table |
| casacore::MSStateColumns | A class to provide easy read-write access to MSState columns |
| casacore::MSStateEnums | Enums for the MeasurementSet STATE table |
| casacore::MSStateGram_global_functions_MSStateGramFunctions | Global functions for flex/bison scanner/parser for MSStateGram |
| casacore::MSStateIndex | Class to handle lookup or indexing into a MS FIELD subtable |
| casacore::MSStateParse | Class to hold values from field grammar parser |
| casacore::MSSummary | Provides and lists information about the header of an image |
| casacore::MSSysCal | A Table intended to hold a MeasurementSet SYSCAL table |
| casacore::MSSysCalColumns | A class to provide easy read-write access to MSSysCal columns |
| casacore::MSSysCalEnums | Enums for the MeasurementSet SYSCAL table |
| casacore::MSSysCalIndex | |
| casacore::MSTable< ColEnum, KeyEnum > | A Table intended to hold astronomical data |
| casacore::MSTableImpl | An implementation class for the MeasurementSet to share code |
| casacore::MSTableIndex | |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MStddevFunc< T > | |
| casacore::MSTileLayout | An helper class for deciding on tile shapes in MeasurementSets |
| casacore::MSTimeGram_global_functions_MSTimeGramFunctions | Global functions for flex/bison scanner/parser for MSTimeGram |
| casacore::MSTimeParse | Class to hold values from time grammar parser |
| casa::MSTransform | MSTransform: Apply transformations to data on the fly |
| casa::MSTransformBufferImpl | |
| casa::MSTransformDataHandler | MSTransformDataHandler definition |
| casa::MSTransformIterator | |
| casa::MSTransformIteratorFactory | A top level class defining the data handling interface for the MSTransform module |
| casa::MSTransformManager | MSTransformManager definition |
| casa::MSTransformRegridder | MSTransformRegridder definition |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MSumFunc< T > | Define functors to perform a reduction function on an MArray object |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MSumSqrFunc< T > | |
| casa::MSUtil | |
| casa::MSUVBin | |
| casacore::MSUvDistGram_global_functions_MSUvDistGramFunctions | Global functions for flex/bison scanner/parser for MSUvDistGram |
| casacore::MSUvDistParse | Class to hold values from UV dist grammar parser |
| casa::MSUVWGenerator | Generates and inserts the (u, v, w)s of a MS that may or may not already have them. Includes antenna offsets when known |
| casacore::MSValidIds | |
| casacore::MSWeather | A Table intended to hold a MeasurementSet WEATHER table |
| casacore::MSWeatherColumns | A class to provide easy read-write access to MSWeather columns |
| casacore::MSWeatherEnums | Enums for the MeasurementSet WEATHER table |
| casacore::MSWeatherIndex | |
| casa::Mueller | |
| casa::MuellerDiag | |
| casa::MuellerDiag2 | |
| casa::MuellerScal | |
| casa::MultiEllipseTool | Base class for MultiWorldCanvas event-based rectangle tools |
| casa::MultiEllipseToolImpl | WorldCanvas event-based ellipse region drawer |
| casacore::MultiFile | Class to combine multiple files in a single one |
| casacore::MultiFileBase | Abstract base class to combine multiple files in a single one |
| casacore::MultiFileInfo | Helper class for MultiFileBase containing info per internal file |
| casacore::MultiHDF5 | Class to combine multiple files in a single HDF5 file |
| casa::MultiParamFieldIterator< N > | |
| casacore::Multiplies< L, R, RES > | Functor to multiply variables of possibly different types |
| casa::MultiPointTool | Base class for MultiWorldCanvas event-based rectangle tools |
| casa::MultiPointToolImpl | WorldCanvas event-based point region drawer |
| casa::MultiPolylineTool | Base class for WorldCanvas event-based polyline tools |
| casa::MultiPolylineToolImpl | WorldCanvas event-based polyline region drawer |
| casa::MultiPolyTool | Base class for WorldCanvas event-based polygon tools |
| casa::MultiPolyToolImpl | WorldCanvas event-based polygon region drawer |
| casa::MultiPVTool | Base class for MultiWorldCanvas event-based rectangle tools |
| casa::MultiPVToolImpl | WorldCanvas event-based rectangle region drawer |
| casacore::MultiRecordFieldWriter | Multi field writer |
| casa::MultiRectTool | Base class for MultiWorldCanvas event-based rectangle tools |
| casa::MultiRectToolImpl | WorldCanvas event-based rectangle region drawer |
| casa::MultiTermAWProjectWBFT | |
| casa::MultiTermFT | |
| casa::MultiTermFTNew | |
| casa::refim::MultiTermFTNew | |
| casacore::MultiTermLatticeCleaner< T > | |
| casa::MultiTermMatrixCleaner | |
| casa::MultiThreadedVisibilityResampler | |
| casa::MultiWCHolder | A holder of WorldCanvasHolders to use for panelling applications |
| casa::MultiWCTool | Base class for MultiWorldCanvas event-based tools |
| casacore::MUString | Pointed String class to aid analysis of quantity strings |
| casacore::MUString_global_functions_output | Global functions |
| casacore::Mutex | Wrapper around a pthreads mutex |
| casa::async::Mutex | |
| casa::sdfiller::Mutex | |
| casacore::MutexedInit | Thread-safe initialization of global variables |
| casa::async::MutexLocker | |
| casacore::Muvw | A Measure: uvw on Earth |
| casacore::MVAngle | Class to handle angle type conversions and I/O |
| casacore::MVAngle_global_functions_output | Global functions |
| casacore::MArrayMath_global_functions_MArray_mathematical_operations::MVarianceFunc< T > | |
| casacore::MVBaseline | A 3D vector on Earth |
| casacore::MVDirection | Vector of three direction cosines |
| casacore::MVDoppler | Internal value for MDoppler |
| casacore::MVDouble | Class to distinguish external and Measure internal Double |
| casacore::MVEarthMagnetic | A 3D Earth magnetic field vector |
| casacore::MVEpoch | A class for high precision time |
| casacore::MVFrequency | Internal value for MFrequency |
| casacore::MVPosition | A 3D vector in space |
| casacore::MVRadialVelocity | Internal value for MRadialVelocity |
| casacore::MVTime | Class to handle date/time type conversions and I/O |
| casacore::MVuvw | A 3D vector on Earth |
| casa::MWCAnimator | Animator for MultiWCHolder class |
| casa::MWCCrosshairTool | Base class for MultiWorldCanvas event-based crosshair tools |
| casa::MWCEllipseTool | Base class for MultiWorldCanvas event-based ellipse tools |
| casa::MWCETRegion | WorldCanvas event-based elliptical region drawer |
| casa::MWCPannerTool | |
| casa::MWCPolylineTool | Base class for WorldCanvas event-based polyline tools |
| casa::MWCPolyTool | Base class for WorldCanvas event-based polygon tools |
| casa::MWCPositionVelocityTool | Multi WorldCanvas event-based position velocity tool |
| casa::MWCPTRegion | WorldCanvas event-based polygon region drawer |
| casa::MWCRectTool | Base class for MultiWorldCanvas event-based rectangle tools |
| casa::MWCRTRegion | WorldCanvas event-based rectangle region drawer |
| casa::MWCRTZoomer | Multi WorldCanvas event-based zoomer |
| casa::MWCRulerlineTool | Multi WorldCanvas event-based ruler line tool |
| Name2Table | |
| casa::NBody | Simple class which provides brute force n-body simulation and display |
| casacore::Near< L, R > | Functor to test if two values are relatively near each other |
| casacore::NearAbs< L, R > | Functor to test for if two values are absolutely near each other |
| negateFunctor< T > | A template functor which returns -|v| |
| casacore::NegativeExpntl | Negative exponential distribution |
| casacore::new_del_allocator< T > | |
| casa::new_interactive_clean_callback | |
| casa::NewCalTable | |
| casacore::NewDelAllocator< T > | An allocator behaves like operator new[]/delete[] |
| casacore::NewFile | Do checks for a new (non-existent) file |
| casacore::NewMSSimulator | Create an empty MeasurementSet from observation and telescope descriptions |
| casa::NewMultiTermFT | |
| casacore::NFalseFunc< T > | |
| casacore::NNGridder< Domain, Range > | A non-negative gridding class |
| casa::NNLSImageSkyModel | Briggs' Non-Negative Least Squares deconvolution algorithm |
| casacore::NNLSMatrixSolver | NNLSMatrixSolver.h: the base class for NNLS solvers of linear equations AX=B |
| casacore::NoConvert< TYPE > | FITS templated helper class |
| casa::NonCopyable< T > | NonCopyable Mixin (CRTP) |
| casa::CalStats::NONE | NONE nested class |
| casacore::NonLinearFit< T > | Class for non-linear least-squares fit |
| casacore::NonLinearFitLM< T > | Solve non-linear fit with Levenberg-Marquardt method |
| casa::NoOpATerm | The base class to represent the Aperture-Term of the Measurement Equation |
| casa::refim::NoOpATerm | |
| casacore::Normal | Normal or Gaussian distribution |
| casa::NoSenPattern | |
| asdm::NoSuchRow | Generate an exception when an expected row cannot be found |
| casacore::Notice | Abstract base class for notices |
| casacore::NoticeSource | Base class for notice originators |
| casacore::NoticeTarget | Abstract base class for notice receptors |
| casa::nPBWProjectFT | |
| casa::NRO2MSReader | |
| casa::sdfiller::NRODataObsHeader | |
| casa::sdfiller::NRODataScanData | |
| casacore::NTrueFunc< T > | |
| casacore::NullLogSink | Throw away all messages |
| casacore::NullTable | Class indicating a null Table object |
| asdm::NumberFormatException | Exception when an error occurs in converting a numeric value from a string |
| casacore::NumericTraits< T > | Relationships between numeric data types |
| casacore::NumericTraits< Complex > | A specialisation for T=Complex of the NumericTraits class |
| casacore::NumericTraits< DComplex > | A specialisation for T=DComplex of the NumericTraits class |
| casacore::NumericTraits< Double > | A specialisation for T=Double of the NumericTraits class |
| casacore::NumericTraits< Float > | A specialisation for T=Float of the NumericTraits class |
| casacore::NumericTraits_C< Complex > | NumericTraits specialization for Complex |
| casacore::NumericTraits_D< Double > | NumericTraits specialization for Double |
| casacore::NumericTraits_DC< DComplex > | NumericTraits specialization for DComplex |
| casacore::NumericTraits_F< Float > | NumericTraits specialization for Float |
| casacore::Nutation | Nutation class and calculations |
| casacore::ObjCompare< T > | Compare two objects |
| casacore::ObjectID | ObjectID: A unique identifier for distributed and other objects |
| casacore::ObjectPool< T, Key > | A parameterized stack of re-usable objects |
| casacore::ObjectStack< T > | A stack of re-usable objects |
| casa::sdfiller::ObservationRecord | |
| asdm::ObservationRow | Row of a ObservationTable |
| asdm::ObservationTable | Alma table |
| casacore::ObsInfo | Store miscellaneous information related to an observation |
| casacore::OddPolynomial< T > | A one dimensional odd polynomial class |
| casacore::OddPolynomial_PS< AutoDiff< T > > | Partial specialization of OddPolynomial for AutoDiff |
| casacore::OddPolynomialParam< T > | Parameter handling for odd polynomials |
| asdmbinaries::Optional< Enum, EnumHelper > | A class to embed optional information |
| casa::viewer::Options | |
| casa::viewer::options_init_ | |
| casacore::OrderedMap< key, value > | Map with keys ordered |
| casacore::OrderedMapIterRep< key, value > | OrderedMap iterator "letter" |
| casacore::OrderedMapNotice< t, v > | Message used for OrderedMap notification |
| casacore::OrderedMapRep< key, value > | Representation class for an Ordered Map |
| casacore::OrderedPair< K, V > | Ordered pair class |
| OrdMapIO_global_functions_OrderedMap_IO | Input/output operators for OrderedMaps |
| casacore::OrdPairIO_global_functions_inoutput | These need to be left out **SUN BUG** |
| casa::OrthographicProjector | |
| casa::CalStats::OUT< T > | Statistics OUT nested class (allowed T: CalStats::NONE, CalStatsFitter::FIT, or CalStatsHist::HIST), used to hold the output of statsWrap<T>() |
| asdm::OutOfBoundsException | Exception when an attempt is made to access something outside of its defined bounds |
| casa::CalAnalysis::OUTPUT< T > | OUTPUT nested class (allowed T: CalStats::NONE, CalStatsFitter::FIT, or CalStatsHist::HIST), used to hold the vector output of stats<T>() |
| casa::OutputDestinationChecker | |
| casa::OutputDestinationChecker::OutputStruct | Struct for checking output file writability |
| casa::dbus::variant::overflow | |
| casa::OverWriteFileDialog | Warns the user that they will be overwriting the output file and provides them with the ability to change to a different output file |
| casacore::PagedArray< T > | A Lattice that is read from or written to disk |
| casacore::PagedArrIter< T > | A read/write Lattice iterator for PagedArrays |
| casacore::PagedImage< T > | Read, store, and manipulate astronomical images |
| casa::PSDriver::PageInfo | The PageInfo struct is used internally to supply descriptions of the various page types |
| casa::QtDBusPlotSvrAdaptor::panel_desc | |
| casa::QtDBusViewerAdaptor::panel_desc | |
| casa::QtDisplayPanel::panel_state | |
| casa::PanelDisplay | A class which creates and manages "panelled" displays |
| casa::ParallelImager | High level interface to parallel imaging classes, instances of which are returned from ParallelImagerFactory::make |
| casa::ParallelImagerAdaptor< T > | Adaptor for ParallelImagerMixin implementation classes as ParallelImager instances |
| casa::ParallelImagerFactory | Factory class for ParallelImager instances |
| casa::ParallelImagerMixin< T > | ParallelImagerMixin |
| casa::ParallelImagerParams | Collection of parameters for parallel imaging, categorized roughly by imaging component |
| casacore::Param | A simple keyword/value pair with internal help Strings |
| casa::viewer::dvo::param | Entry of flexible VO parameters |
| casa::ParameterParser | Parse various common input parameters to image analysis tasks and tool methods <author>Dave Mehringer</author> |
| casa::ParamFieldIterator | |
| casa::RegionTextParser::ParamValue | Because of nonstandard access patterns, be careful when using ParamValue and ParamSet outside this class; These should probably be made into full fledged classes at some point; |
| casa::ParAngleChangeDetector | ////////////////////////////////////////////////////////////////////////// |
| casa::refim::ParAngleChangeDetector | ////////////////////////////////////////////////////////////////////////// |
| casacore::ParAngleColumn | Parallactic angle derived from TIME, etc |
| casacore::ParAngleMachine | Converts a direction into parallactic angle |
| asdm::Parser | A Parser of for XML representation of ASDM datasets |
| ParserContext< T, R, RFilter > | |
| asdm::PartId | Description |
| casa::Partition | Bool isAllColumns(const Vector<MS::PredefinedColumns>& colNames); |
| casa::PassiveCachingDD | Class providing passive behaviour for CachingDisplayDatas |
| casa::PassiveTableDD | Class adding Table-specific support functions to PassiveCachingDD |
| casacore::Path | Path name of a file |
| casa::Pathology | |
| casa::PBMath | Primary beam envelope class, derived from PBMathInterface |
| casa::PBMath1D | Base class for 1D PBMath objects |
| casa::PBMath1DAiry | PBMath1DAiry is a 1-D Airy Disk voltage pattern & Primary Beam |
| casa::PBMath1DCosPoly | PBMath1DCosPoly is a 1-D Polynomial Cosine Expansion for a Primary Beam |
| casa::PBMath1DEVLA | |
| casa::PBMath1DGauss | PBMath1DGauss is a 1-D Gaussian Primary Beam |
| casa::PBMath1DIPoly | PBMath1DIPoly is a 1-D Inverse Polynomial Expansion for a Primary Beam |
| casa::PBMath1DNumeric | 1-D Numeric Primary Beam Model |
| casa::PBMath1DPoly | PBMath1DPoly is a 1-D Polynomial Expansion for a Primary Beam |
| casa::PBMath2D | Base class for 1D PBMath objects |
| casa::PBMath2DImage | 2-D Image Primary Beam Model |
| casa::PBMathInterface | Virtual base class defining the Primary Beam interface |
| casa::PBMosaicFT | Class nPBWProjectFT; |
| casa::PCFSpectralElement | Abstract base class that describes a spectral profile that can be parameterized by a peak value (amplitude), center, and width |
| casa::PCInvisTool | Base implementation of PCTool for invisible (non-drawing) tools |
| casa::PCITFiddler | Colormap fiddling on the PixelCanvas |
| casa::PClarkCleanImageSkyModel | Clark Image Sky Model: Image Sky Model implementing the Clark Clean algorithm |
| casa::PCMotionEH | PixelCanvas Event Handler for managing pointer motion events |
| casa::PCMotionEvent | Class which stores PixelCanvas motion event information |
| casa::sdfiller::PCondition | |
| casa::PCPositionEH | PixelCanvas Event Handler for managing keyboard and mouse button events |
| casa::PCPositionEvent | Class which stores PixelCanvas position event information |
| casa::PCRefreshEH | WorldCanvas Event Handler for managing events |
| casa::PCRefreshEvent | Class which stores PixelCanvas refresh event information |
| casa::PCTestPattern | PixelCanvas test pattern display refresh event handler |
| casa::PCTool | Base class for PixelCanvas event-based tools |
| casa::PCToolMotEH | PixelCanvas motion event handler for PCTool |
| casa::PCToolPosEH | PixelCanvas position event handler for PCTool |
| casa::PCToolRefEH | PixelCanvas refresh event handler for PCTool |
| casa::PCVGBuffer | |
| casa::PeakIntensityFluxDensityConverter | |
| casa::vi::VisibilityIteratorImpl2::PendingChanges | |
| casa::PercentageCalculator | Designed as a separaclass so if it needs to go into a different thread, it can be put there |
| casa::PGPLOT_global_functions_interface | PGPLOT interface calls |
| casacore::PGPlotter | Standard plotting object for application programmers |
| casacore::PGPlotterInterface | Abstract base class for PGPLOT style plotting |
| casa::PGPlotterLocal | Plot to a PGPLOT device "local" to this process |
| casacore::PGPlotterNull | Plot to a PGPLOT device "local" to this process |
| casa::vi::PhaseShiftingTransformEngine | |
| casa::vi::PhaseShiftingTVI | |
| casa::vi::PhaseShiftingTVIFactory | |
| casa::vi::PhaseShiftTvi | |
| casa::PictureViewer | |
| casa::PixelatedConvFunc< T > | |
| casa::PixelCanvas | Base class defining interface to pixel-based output devices |
| casa::PixelCanvasColorTable | Abstract interface to underlying graphics library's colortable |
| casa::PixelCanvasEvent | Base class describing event information for PixelCanvases |
| casacore::PixelCurve1D | Arbitrary 1-dim curve in a lattice plane |
| casa::PixelRangeDialog | Displays a histogram that allows the user to set a include/exclude pixel range for the fit |
| casa::PixelValueManipulator< T > | |
| casa::PixelValueManipulatorData | |
| casa::PixonProcessor | Allows processing via the Pixon algorithm |
| casa::PJones | ********************************************************** PJones |
| casa::PJonesDesc | PJonesDesc: Define the format of PJones cal tables |
| casa::PJonesMBuf | PJonesMBuf: PJones calibration main table buffer |
| casa::PJonesMCol | PJonesMCol: RW PJones cal_main column access |
| casa::PJonesMRec | PJonesMRec: PJones cal_main table record access & creation |
| casa::PJonesTable | PJonesTable: PJones calibration table access and creation |
| casa::vi::PlainChannelAverageKernel | |
| casacore::PlainColumn | Base class for a column in a plain table |
| casacore::PlainTable | Class defining a plain regular table |
| casa::Plot | A Plot basically consists of data and customization information |
| casa::QtPlotSvrPanel::row_desc::plot_desc | |
| casa::PlotAnnotation | PlotAnnotation is an abstraction of text written directly on the canvas |
| casa::PlotAreaFill | Abstract class for area fill |
| casa::PlotAxesStack | A PlotAxesStack is basically a list of PlotRegions as well as axis information that provides stack functionality such as a current index, and moving up and down the stack |
| casa::PlotButton | Generic class for a button that goes on a PlotPanel |
| casa::PlotButtonEvent | Event for when a PlotButton is pressed |
| casa::PlotButtonEventHandler | Base class for a handler for PlotButtonEvent |
| casa::PlotCanvas | PlotCanvas is an area for different PlotItems to be attached and drawn |
| casa::PlotCanvasLayout | Base class for any layout |
| casa::PlotCheckbox | Generic class for a checkbox that goes on a PlotPanel |
| casa::PlotCheckboxEvent | Event for when a PlotCheckbox is clicked |
| casa::PlotCheckboxEventHandler | Base class for a handler for PlotCheckboxEvent |
| casa::PlotClickEvent | Convenience class for mouse clicks |
| casa::PlotClickEventHandler | Base class for a handler for PlotClickEvent |
| casa::PlotColor | |
| casa::PlotColorWidget | Widget for choosing a plot color |
| casa::PlotData | |
| casa::PlotDrawWatcher | Abstract parent for any class that wants to be notified when the canvas is about to start drawing |
| casa::PlotEngine | Abstracts the interface DBUS uses to talk to the main PlotMS application |
| casa::PlotErrorDataImpl< T > | Default implementation of PlotErrorData using standard containers, plus PlotPointDataImpls for the errors |
| casa::PlotEvent | Base class for an event |
| casa::PlotExportFormat | PlotExportFormat contains parameters for exporting a canvas to a file |
| casa::PlotFactory | The idea behind a plot factory is to produce classes that are useful to the underlying implementation without having to know what the implementation is |
| casa::PlotFillWidget | Widget for choosing a plot area fill |
| casa::PlotFont | Abstract class for fonts |
| casa::PlotFontWidget | Widget for choosing a plot font |
| casa::PlotGridCoordinate | |
| casa::PlotHistogramData | Specialized subclass of PlotPointData that creates histogram data from single point data |
| casa::PlotHolder | |
| casa::PlotItem | PlotItem is the superclass of any object that is meant to be placed on the canvas (plots, annotations, shapes, etc |
| casa::PlotKeyEvent | Event for when the user makes a keyboard command when a canvas has focus |
| casa::PlotKeyEventHandler | Base class for a handler for PlotKeyEvent |
| casa::PlotLayoutCoordinate | |
| casa::PlotLayoutGrid | An n x m grid of canvases |
| casa::PlotLayoutSingle | |
| casa::PlotLine | Abstract class for a line |
| casa::PlotLineWidget | Widget for choosing a plot line |
| casa::PlotLogger | A PlotLogger is used to log messages to an underlying CASA log object, as well as provide access to different logging functionality like measurements |
| casa::PlotLoggerFilter | Subclass of LogFilterInterface to filter on both event flags and minimum priority |
| casa::PlotLogLocate | Used to report located indices |
| casa::PlotLogMeasurement | Used to report time and memory measurements |
| casa::PlotLogMessage | Superclass for all messages going through the PlotLogger |
| casa::PlotLogMethod | Subclass of PlotLogMessage to unify messages for method entering/exiting |
| casa::PlotLogObject | Subclass of PlotLogMessage to unify messages for object creation/deletion |
| casa::PlotMaskedPointData | Data that adds masking functionality on top of normal point data |
| casa::PlotMaskedPointDataImpl< T > | Default implementation of PlotMaskedPointData using default containers |
| casa::PlotMouseDragEvent | Convenience class for mouse drags |
| casa::PlotMouseDragEventHandler | Base class for a handler for PlotMouseDragEvent |
| casa::PlotMouseEvent | Generic mouse event where the canvas is the origin, and the type, button, and location of the event are provided |
| casa::PlotMouseMoveEvent | Convenience class for mouse moves |
| casa::PlotMouseMoveEventHandler | Base class for a handler for a PlotMouseMoveEvent |
| casa::PlotMousePressEvent | Convenience class for mouse presses |
| casa::PlotMousePressEventHandler | Base class for a handler for PlotMousePressEvent |
| casa::PlotMouseReleaseEvent | Convenience class for mouse releases |
| casa::PlotMouseReleaseEventHandler | Base class for a handler for PlotMouseReleaseEvent |
| casa::PlotMouseTool | A PlotMouseTool is a specialization of PlotTool that handles all mouse events |
| casa::PlotMSAction | ABSTRACT CLASSES // |
| casa::PlotMSAnnotator | Subclass of PlotMouseTool for drawing/managing annotations on the plot canvases of PlotMSApp |
| casa::PlotMSAnnotatorTab | Subclass of PlotMSTab that handles interaction with the PlotMSAnnotator |
| casa::PlotMSApp | Controller class for plotms |
| casa::PlotMSAveraging | Specifies averaging parameters for an MS |
| casa::PlotMSAveragingWidget | GUI widget for editing a PlotMSAveraging object |
| casa::PlotMSAxesTab | Subclass of PlotMSPlotSubtab that manages plot axes parameters |
| casa::PlotMSAxisWidget | Widget for choosing a single axis |
| casa::PlotMSCacheBase | |
| casa::PlotMSCacheTab | |
| casa::PlotMSCacheThread | Subclass of PlotMSThread for loading axes in a PlotMSCache |
| casa::PlotMSCalibration | Specifies calibration parameters for an MS |
| casa::PlotMSCalibrationTab | Subclass of PlotMSTab that handles using a calibration library (initially settable only from casapy session) |
| casa::PlotMSCalibrationWidget | Widget for editing a PlotMSCalibration object |
| casa::PlotMSCanvasTab | Subclass of PlotMSPlotSubtab to manage canvas parameters |
| casa::PlotMSDataCollapsible | Represents a single plot's properties that can be shown maximized or minimized; handles whether a plot will be shown on the display |
| casa::PlotMSDataSummaryTab | Handles adding multiple plots to the GUI |
| casa::PlotMSDataSymbolWidget | Represents how symbols are colored and drawn on the plot |
| casa::PlotMSDataTab | Subclass of PlotMSTab that handles picking MS filename, selection, and averaging parameters |
| casa::PlotMSDBusApp | Class PlotEngine; |
| casa::PlotMSDisplayTab | Subclass of PlotMSPlotSubtab to manage plot display parameters |
| casa::PlotMSDrawThread | Subclass of PlotMSThread that handles following the progress of canvas drawing |
| casa::PlotMSExportParam | Specifies export parameters for plotms |
| casa::PlotMSExportTab | Subclass of PlotMSPlotSubtab to manage exporting plots |
| casa::PlotMSExportThread | Subclass of PlotMSThread for exporting a plot |
| casa::PlotMSFlagging | Specifies flagging parameters (including possibly flag extension) for an MS |
| casa::PlotMSFlaggingTab | Subclass of PlotMSTab that handles flagging |
| casa::PlotMSFlaggingWidget | GUI widget for editing a PlotMSFlagging object |
| casa::PlotMSIndexer | |
| casa::PlotMSIterateTab | Subclass of PlotMSPlotSubtab to manage plot display parameters |
| casa::PlotMSIterParam | Specifies iteration parameters for plotms |
| casa::PlotMSLabelFormat | Class for generating labels based upon axes, units, etc |
| casa::PlotMSLoggerWidget | Widget to set log events and priority filter |
| casa::PlotMSOptionsTab | Subclass of PlotMSTab that handles options for PlotMSPlotter |
| casa::PlotMSPage | Represents a single page of PlotCanvases, arranged in a grid |
| casa::PlotMSPages | Represents (potentially) multiple pages for PlotMS, with one being current (visible) at a time |
| casa::PlotMSParameters | Subclass of PlotMSWatchedParameters that hold parameters for the whole plotter |
| casa::PlotMSParametersWatcher | Interface for classes that wish to be notified when PlotMSWatchedParameters have changed |
| casa::PlotMSPlot | Class for a single "plot" concept |
| casa::PlotMSPlotManager | Class which manages PlotMSPlots for plotms |
| casa::PlotMSPlotManagerWatcher | Interface for any class that wants to be notified when the plots in the manager have changed |
| casa::PlotMSPlotParameters | Parameters for a PlotMSPlot |
| casa::PlotMSPlotSubtab | Subclass of PlotMSTab for tabs that are meant to be used as subtabs in a PlotMSPlotTab |
| casa::PlotMSPlotTab | Subclass of PlotMSTab that manages PlotMSPlots in the GUI |
| casa::PlotMSPlotter | High(ish)-level plotter class that manages the GUI (semi-) transparently to the rest of PlotMS |
| casa::PlotMSPolSelection | |
| casa::PlotMSRegion | A single region; basically just a container class for four doubles |
| casa::PlotMSRegions | PlotMSRegions is a class that holds information about selected regions for a single PlotMSPlot |
| casa::PlotMSSelection | Specifies an MS selection |
| casa::PlotMSSelectionWidget | Widget for editing a PlotMSSelection object |
| casa::PlotMSSummaryDialog | Contains controls for customizing and producing a summary of the plot |
| casa::PlotMSTab | Abstract parent for any widget that goes in the tabbed side panel of the PlotMSPlotter |
| casa::PlotMSThread | Abstract class to control a threaded operation from the GUI |
| casa::PlotMSToolsTab | Subclass of PlotMSTab that handles the tools for the current plot |
| casa::PlotMSTransformations | Specifies averaging parameters for an MS |
| casa::PlotMSTransformationsTab | Subclass of PlotMSTab that handles picking MS filename, selection, and averaging parameters |
| casa::PlotMSTransformationsWidget | Widget for editing a PlotMSTransformations object |
| casa::PlotMSVBAverager | A class to average VisBuffers for PlotMS |
| casa::PlotMSWatchedParameters | Abstract class for parameters that may be watched by one or more interested classes |
| casa::PlotMutex | Abstract class, for a synchronization mutex specific to the threading library used by the plotting implementations |
| casa::PlotOperation | Simple object to synchronize operation progress information across threads |
| casa::PlotOperationWatcher | Abstract interface for any object that wants to watch a PlotOperation object for changes |
| casa::PlotPanel | A PlotPanel is a panel that goes on the bottom of the plot window |
| casa::PlotPanToolNotifier | Interface for objects that want to be notified when the pan tool changes |
| casa::PlotParams | Parameters for a single field for collecting plotting data |
| casa::PlotPoint | Abstract class for a single point on the canvas (not descended from PlotShape) |
| casa::PlotPointData | A source of data used to supply x and y values |
| casa::PlotPointDataImpl< T > | Default implementation of PlotPointData that supports raw arrays, vectors, and CASA Vectors |
| casa::PlotRangeWidget | Widget for selecting a plot axis range |
| casa::PlotRasterMatrixData< T > | Implementation of raster data using casa::Matrix |
| casa::PlotRegion | A PlotRegion is basically just a wrapper for two PlotCoordinates: an upper left coordinate and a lower right coordinate |
| casa::PlotResizeEvent | Event for when a canvas or plotter is resized |
| casa::PlotResizeEventHandler | Base class for a handler for PlotResizeEvent |
| casa::PlotScalarErrorDataImpl< T > | Default implementation of PlotErrorData using standard containers, plus scalars for the four errors |
| casa::PlotSelectEvent | Event for when the user selects a region on a plot canvas with the mouse |
| casa::PlotSelectEventHandler | Base class for a handler for PlotSelectEvent |
| casa::PlotSelectTool | A PlotSelectTool is a concrete subclass of PlotMouseTool that mainly handles select events |
| casa::PlotServerProxy | |
| casa::PlotShape | Abstract class for any shape which contains common functionality |
| casa::PlotShapeArc | Specialization of PlotShape for an arc |
| casa::PlotShapeArrow | Specialization of PlotShape for an arrow |
| casa::PlotShapeEllipse | Specialization of PlotShape for an ellipse |
| casa::PlotShapeLine | Specialization of PlotShape for a line |
| casa::PlotShapePath | Specialization of PlotShape for a path |
| casa::PlotShapePolygon | Specialization of PlotShape for a polygon |
| casa::PlotShapeRectangle | Specialization of PlotShape for a rectangle |
| casa::PlotSingleData | A single source of data that basically provides indexing of its values |
| casa::PlotSingleDataImpl< T > | |
| casa::PlotSlicer | Small widget to provide a variable number of spinners to create a slice |
| casa::PlotSymbol | Abstract class for a symbol |
| casa::PlotSymbolWidget | Widget for choosing a plot symbol |
| casa::Plotter | A Plotter can be thought of as a frame that holds one or more PlotCanvases in a configuration determined by a given PlotCanvasLayout |
| casa::PlotterImplementations | |
| casa::PlotTool | |
| casa::PlotTrackerToolNotifier | Interface for objects that want to be notified when the tracker tool changes |
| casa::PlotWheelEvent | Event for when the user scrolls the scroll wheel |
| casa::PlotWheelEventHandler | Base class for a handler for PlotWheelEvent |
| casa::PlotWidget | Abstract superclass for any widget that goes on a PlotPanel |
| casa::PlotZoomToolNotifier | Interface for objects that want to be notified when the zoom tool changes |
| casacore::Plus< L, R, RES > | Functor to add variables of possibly different types |
| casa::PMS | Container class for useful constants/methods |
| casa::PMS_PP | Container class to hold constants for groups |
| casa::PMS_PP_Axes | Subclass of PlotMSPlotParameters::Group to handle axes parameters |
| casa::PMS_PP_Cache | Subclass of PlotMSPlotParameters::Group to handle cache parameters |
| casa::PMS_PP_Canvas | Subclass of PlotMSPlotParameters::Group to handle canvas parameters |
| casa::PMS_PP_Display | Subclass of PlotMSPlotParameters::Group to handle display parameters |
| casa::PMS_PP_Iteration | Subclass of PlotMSPlotParameters::Group to handle iteration parameters |
| casa::PMS_PP_MSData | Subclass of PlotMSPlotParameters::Group to handle subparameters for MS data |
| casa::viewer::Point | All regions are specified in "linear coordinates", not "pixel coordinates" |
| casacore::LSQType< T >::PointerTraits< U > | |
| casacore::LSQType< T >::PointerTraits< U * > | |
| casa::viewer::region::PointInfo | |
| casa::PointingDirectionCalculator | |
| asdm::PointingModelRow | Row of a PointingModelTable |
| asdm::PointingModelTable | Alma table |
| asdm::PointingRow | Row of a PointingTable |
| asdm::PointingTable | Alma table |
| casa::viewer::PointMarkerState | Used to pass point specific marker information (marker type and scaling) to generic region creation routines RegionTool::create( |
| casa::PointShape | A shape where emission comes from only one direction |
| casacore::Poisson | Poisson distribution |
| casacore::PoissonFunction< T > | A one dimensional Poisson function |
| casacore::PoissonFunction_PS< AutoDiff< T > > | Partial specialization of PoissonFunction for AutoDiff |
| casacore::PoissonParam< T > | A one dimensional Poisson function |
| asdm::PolarizationRow | Row of a PolarizationTable |
| asdm::PolarizationTable | Alma table |
| casa::PolOuterProduct | |
| casa::refim::PolOuterProduct | |
| casa::viewer::Polygon | |
| casa::viewer::Polyline | |
| casacore::Polynomial< T > | A one dimensional polynomial class |
| casacore::Polynomial_PS< AutoDiff< T > > | Partial specialization of Polynomial for AutoDiff |
| casacore::PolynomialParam< T > | Parameter handling for one-dimensional polynomials |
| casa::PolynomialSpectralElement | Describes a polynomial spectral profile |
| casa::PolynomialSpectralElement_global_functions_Output | Global functions |
| casacore::PoolStack< T, Key > | A parameterized stack of re-usable objects |
| casa::viewer::Position | Why not use MDirection? It's limited by valid astronomical coordinates on the sky Hz vs arcsec does not fly |
| casacore::Pow< T, E, RES > | Functor to apply pow |
| casacore::Pow3< T, RES > | Functor to apply a power of 3 |
| casacore::PowerLogarithmicPolynomial< T > | A one dimensional power logarithmic polynomial class of form y = c_0 * x**( c_1 + c_2*ln(x) + c_3*ln(x)**2 + ... c_n*ln(x)**(n-1)) |
| casacore::PowerLogarithmicPolynomial_PS< AutoDiff< T > > | Partial specialization of PowerLogarithmicPolynomial for AutoDiff |
| casacore::PowerLogarithmicPolynomialParam< T > | Parameter handling for one-dimensional power logarithmic polynomials |
| casa::PowerLogPolynomialSpectralElement | Describes the function most often used for determining spectral index plus higher order terms: y = c_0 * x**( c_1 + c_2*ln(x) + c_3*ln(x)**2 + ... ) where c_1 is the traditional spectral index (alpha) |
| casacore::Precession | Precession class and calculations |
| casacore::PrecTimer | Precision timer to measure elapsed times in a cumulative way |
| casa::PredictAlgorithm | Parallel model visibility prediction |
| casa::Preferences | |
| casa::viewer::Preferences | |
| casa::PreferencesColor | Manages the display properties of all the curves that can be shown on the plots |
| casa::PreferencesFunction | Displays, handles persistence, and stores display properties for a particular curve that can be shown on the plot |
| casa::asyncio::PrefetchColumns | Used to specify a set of columns that can be prefetched when the (RO)VisibilityIterator is using asynchronous I/O |
| asdm::Pressure | Implements a quantity of pressure in hectopascals |
| casacore::PrimaryArray< TYPE > | Templated primary array base class of given type |
| casacore::PrimaryGroup< TYPE > | Random Group datastructure |
| casacore::PrimaryTable< TYPE > | Primary Table structure |
| casacore::Primes | Creates a reference table of prime numbers, and some functions |
| casa::PrincipalAxesDD | Interface for DisplayDatas which have data arranged in axes |
| casa::PrincipalAxesDM | Interface for DisplayMethods which have data arranged in "axes." |
| casa::sdfiller::ProcessorRecord | |
| asdm::ProcessorRow | Row of a ProcessorTable |
| asdm::ProcessorTable | Alma table |
| casa::sdfiller::ProducerConsumerModelContext< DataType, BufferSize > | Implementation of producer consumer model |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::ProductFunc< T > | |
| casa::Profile2dDD | A DisplayData to draw Profiles |
| casa::Profile2dDM | A DisplayMethod to draw Profiles |
| casa::ProfileFit1D< T > | Fit spectral components to a Vector of data |
| casa::ProfileFitMarker | |
| casa::ProfileFitResults | |
| casa::ProfileFitterEstimatesFileParser | Class for parsing a file which holds initial estimates for 1-D components. Used by ImageProfileFitter |
| casa::ProfileTaskFacilitator | |
| casa::ProfileTaskMonitor | |
| casa::ProgressBar | |
| casa::ProgressHelper | Wrapper around a QProgressPanel or other QLabel/QProgressBar pairing |
| casacore::ProgressMeter | Visual indication of a tasks progress |
| casa::ProgressMonitor | Abstraction for a display widget that can show the progress of an operation |
| casa::ProgressTimer | |
| casacore::Projection | Geometric parameters needed for a sky projection to a plane |
| casa::Projector | Partially projection code from ASAP GenericEdgeDetector |
| casa::PropertyListener | |
| casa::ProtoVR | |
| casa::PSDriver | Low level interface between PSPixelCanvas{ColorTable} and PostScript |
| casa::PSFZero | |
| casa::PSDriver::PSInfo | PSInfo is used to supply comment fields for the PostScript header and other information that needs to be available when the PSDriver object is created |
| casa::PSPixelCanvas | Implementation of the PixelCanvas for PostScript devices |
| casa::PSPixelCanvasColorTable | Implementation of PixelCanvasColorTable for PostScript device |
| casa::PSDriver::PSState | Holds our copy of the current transformation matrix |
| casa::PSTerm | A class to apply the W-Term to the given image |
| casa::refim::PSTerm | A class to apply the W-Term to the given image |
| casa::PSWorldCanvasApp | Simple PostScript WorldCanvas application |
| casa::PTransport | Base class for parallel data transport models |
| casacore::PtrBlock< T > | A drop-in replacement for Block<T*> |
| casacore::PtrHolder< T > | Hold and delete pointers not deleted by object destructors |
| casacore::PutCellSlices< T > | Functor to put irregular array slices into a cell |
| casacore::PutColumnSlices< T > | Functor to get irregular array slices from a column |
| casa::PVGenerator | |
| casa::viewer::PVLine | All regions are specified in "linear coordinates", not "pixel coordinates" |
| casa::viewer::qt::pvline_stats_t | |
| casa::viewer::PVLineRegionInfo | |
| casa::PWFCleanImageSkyModel | Parallelized version of class WFCleanImageSkyModel |
| casacore::QBase | Base for Quantities (i.e. dimensioned values) |
| casacore::QBase_global_functions_Output | Global functions |
| casacore::QC | Physical constants (i.e. dimensioned values) |
| casacore::QC_global_functions_QC_initialization_object | Object used to force construction of QC |
| casacore::QC_init | Class used to force construction of QC |
| casa::QCloseableWidget | Wrapper around a QWidget with a "Close" button |
| casa::QFontColor | QFont color is a convenience class containing a QFont and a QColor |
| casacore::QLogical_global_functions_Quantum_logical_operations | Logical operations for the Quantum class |
| casacore::QMath_global_functions_Quantum_mathematical_operations | Mathematical operations for the Quantum class |
| casa::QPArrow | Used by the viewer's region shapes, so have it outside the ifdefs in case the flag isn't on |
| casa::QPExportCanvas | Interface implemented by classes that can export their draw area (QPAxis & QPCanvas) |
| casa::QPExporter | Utility class for exporting plots |
| casa::QProgressPanel | Convenience class with a label and progress meter |
| casa::QtActionGroup | This class meant to be used almost identically to an exclusive QActionGroup |
| casa::QtActionSynchronizer | This class is used to synchronize the checked state of actions with checkable buttons or other actions |
| casa::QtAdjustmentTop | |
| casa::QtAnnotatorGui | Annotating widget for a display panel |
| casa::QtApp | Management of the QApp object needed by any Qt application |
| casa::QtAutoGui | General-purpose Qt options widget created from Record |
| casa::QtBool | |
| casa::QtBorderLayout | |
| casa::QtButtonGroup | This class meant to be used almost identically to an exclusive QButtonGroup |
| casa::QtCanvas | |
| casa::QtCanvasManager | |
| casa::QtCanvasManagerOptions | Options widget for single DisplayPanel |
| casa::QtCheck | |
| casa::QtCleanPanelGui | |
| casa::QtCleanPanelGui2 | |
| casa::QtColorWidget | A widget that lets the user select a color: either one from a list, or a custom color |
| casa::QtCombo | |
| casa::QtComboCheckBox | Subclass of QComboBox that uses the item delegate above |
| casa::QtComboCheckBoxDelegate | Subclass of QItemDelegate for use with QtComboCheckBox |
| casa::QtCrossTool | |
| casa::QtDataManager | |
| casa::QtDataOptionsPanel | |
| casa::QtDBusApp | |
| casa::QtDBusPlotSvrAdaptor | |
| casa::QtDBusViewerAdaptor | |
| casa::QtDBusXML | Subclass of QDomDocument that represents an XML scheme that is to be used with CASA's Qt dbus communication |
| casa::QtDBusXmlApp | Abstract parent of classes that want to register themselves with CASA's DBus server |
| casa::QtDBusXmlAppAdaptor | Subclass of QDBusAbstractAdaptor for use with CASA's QtDBusXmlApp class |
| casa::QtDisplayData | |
| casa::QtDisplayDataGui | Qt options widget for single DisplayData |
| casa::QtDisplayPanel | |
| casa::QtDisplayPanelGui | The main display window for the Qt version of the viewer |
| casa::QtDrawCanvas | |
| casa::QtDrawColors | |
| casa::QtDrawer | |
| casa::QtDrawSettings | |
| QtDS9RFWOptions | Widget used for entering options specific to the DS9 format |
| casa::QtEditingWidget | A simple parent for editing widgets |
| casa::QtEditRegionShape | Dialog for editing a single region shape |
| casa::QtEllipseTool | |
| casa::QtELRegion | |
| casa::QtExportBrowser | |
| casa::QtExportManager | |
| casa::QtFileDialog | Subclass of QFileDialog with additional functionality |
| casa::QtFileWidget | Widget for choosing a file |
| casa::QtFlowLayout | |
| casa::QtId | |
| casa::QtIndexChooser | Widget that allows the user to pick an index, with a number of choices on how the index can be chosen |
| casa::QtLabelWidget | Widget for choosing a label |
| casa::QtLayeredLayout | Subclass of QLayout to have multiple widgets layered on top of each other |
| casa::QtLELEdit | |
| casa::QtLineEditor | |
| casa::QtMarkerGui | |
| casa::QtMinMaxEditor | |
| casa::QtMouseTool | |
| casa::QtMouseToolBar | |
| casa::QtMouseToolButton | |
| casa::QtMouseToolState | |
| casa::QtMWCTool | |
| casa::QtNewRegionShape | Dialog for creating a new region shape |
| casa::QtNewRSComposite | Specialized widget for creating a new composite |
| casa::QtNewRSPolygon | Specialized widget for creating a new polygon |
| casa::QtNumberEditor | Can use PairItem because it's just a frame |
| casa::QtOldCrossTool | |
| casa::QtOldEllipseTool | |
| casa::QtOldELRegion | |
| casa::QtOldMouseTool | |
| casa::QtOldMWCTool | |
| casa::QtOldPolyTool | |
| casa::QtOldPTRegion | |
| casa::QtOldRectTool | |
| casa::QtOldRTRegion | |
| casa::viewer::QtOptionsKernel | |
| casa::QtPairEditor | |
| casa::QtPanelBase | |
| casa::QtPCColorTable | |
| casa::QtPlotFrame | |
| QtPlotHistogram | |
| casa::QtPlotServer | |
| casa::QtPlotSettings | |
| casa::QtPlotSvrMain | |
| casa::QtPlotSvrPanel | |
| casa::QtPlotter | |
| casa::QtPlotWidget | Parent for plot widgets |
| casa::QtPointRegion | |
| casa::viewer::QtPointState | |
| casa::QtPointToolButton | |
| casa::QtPolylineTool | |
| casa::QtPolylineToolRegion | |
| casa::QtPolyTool | |
| casa::QtProfile | Note: The purpose of the SpecFitMonitor interface is to provide a communications interface between the class doing spectral line fitting and this class |
| casa::QtProfilePrefs | |
| casa::QtProgressWidget | GUI for displaying progress information |
| casa::QtPTRegion | |
| casa::QtPushButton | |
| casa::viewer::QtPVLineState | |
| casa::QtPVTool | |
| casa::QtPVToolRegion | |
| casa::QtRasterData | |
| casa::QtRectTool | |
| casa::viewer::QtRegionDock | |
| casa::QtRegionEditor | |
| casa::QtRegionManager | |
| casa::QtRegionShapeManager | Region Shape Manager |
| casa::viewer::QtRegionSource | |
| casa::viewer::QtRegionSourceFactory | |
| casa::viewer::QtRegionSourceKernel | |
| casa::viewer::QtRegionState | |
| casa::viewer::QtRegionStats | |
| casa::QtRSFileLoader | Class for loading region shape files |
| casa::QtRSFileSaver | Class for saving region files |
| casa::QtRSOption | Widget that can be used to input a String, String choice, double, bool, String array, or String choice array |
| casa::QtRTRegion | |
| casa::QtSingleRegionShape | Widget for displaying a single region in the list of a QtRegionShapeManager |
| casa::viewer::QtSliceCutState | |
| casa::QtSliderBase | Base class for QtAutoGui slider interface elements |
| casa::QtSliderEditor | |
| casa::QtSliderLabel | |
| casa::QtUtilities | |
| casa::QtViewer | Qt implementation of main viewer supervisory object -- Gui level |
| casa::QtViewerBase | |
| casa::QtViewerPrintCtl | Viewer print widget |
| casa::QtViewerPrintGui | |
| casa::QtWCBox | |
| casa::QtXmlRecord | |
| casacore::Quality | Quality parameter definitions |
| casacore::QualityCoordinate | Interconvert between pixel and Quality value |
| casacore::Quantum< Qtype > | Quantities (i.e. dimensioned values) |
| casacore::Quantum_global_functions_output | Global functions |
| casacore::QuantumHolder | A holder for Quantums to enable record conversions |
| casacore::QuantumType_global_functions_QuantumType | Get an integer type for a Qunatum<T> |
| casacore::Queue< T > | A First-In-First-Out (FIFO) data structure |
| casacore::QVector< T > | Specialization for Quantum<Vector<T> > |
| casacore::Random | Base class for random number distributions |
| casa::RangeControlsWidget | Pluggable functionality that allows users to specify a range on the histogram |
| casa::viewer::RangeLimiter< T > | Class for applying a range limit to values |
| casa::RangePicker | Handles drawing the range selection rectangle for the bin plot |
| casa::RasterPlot | Plot used to show raster (image-like) data |
| casacore::RawDataConversion | A class with virtual functions to copy without conversion |
| casacore::RawIO | Class for IO in local format |
| casa::Ray | |
| casacore::re_pattern_buffer | This data structure is used to represent a compiled pattern |
| casacore::re_registers | Data structure to store register contents data in |
| casacore::ReadAsciiTable | Helper class for readAsciiTable |
| casacore::ReadAsciiTable_global_functions_readAsciiTable | Filling a table from an Ascii file |
| casa::ReaderInterface | |
| casa::ReadMSAlgorithm | Test class to read in parallel a MS |
| casacore::ReadOnlyArrayIterator< T > | Iterate a const Array cursor through a const Array |
| casacore::ReadOnlyMatrixIterator< T > | Iterate a Matrix cursor through a R/O Array |
| casacore::ReadOnlyVectorIterator< T > | Iterate a Vector cursor through another Array |
| casacore::Real< T, RES > | Functor to apply complex function real |
| casacore::LSQFit::Real | Simple classes to overload templated memberfunctions |
| casacore::casacore_allocator< T, ALIGNMENT >::rebind< TOther > | |
| casacore::new_del_allocator< T >::rebind< TOther > | |
| casacore::std11_allocator< T >::rebind< TOther > | |
| casacore::RebinImage< T > | Rebin an image |
| casacore::RebinLattice< T > | Rebin a masked lattice |
| asdm::ReceiverRow | Row of a ReceiverTable |
| asdm::ReceiverTable | Alma table |
| casa::dbus::record | Todo: o create python to/from record functions o implement compare() o implement record_to_string() o create a thorough test program o verify that std::map<>'s copy ctor does a complete copy o add copy-on-write (w/ reference counting) |
| casacore::Record | A hierarchical collection of named fields of various types |
| casacore::RecordDesc | Description of the fields in a record object |
| casacore::RecordDescRep | Representation of a RecordDesc |
| casacore::RecordExpr_global_functions_RecordExpr | Global functions to make a expression node for a record field |
| casacore::RecordFieldCopier< outType, inType > | Record field copier |
| casacore::RecordFieldId | The identification of a record field |
| casacore::RecordFieldPtr< T > | Access to an individual field in a record |
| casacore::RecordFieldWriter | Record field writer. Base class for the copiers |
| casacore::RecordGram | Select-class for flex/bison scanner/parser for RecordGram |
| casacore::RecordGram_global_functions_RecordGramFunctions | Global functions for flex/bison scanner/parser for RecordGram |
| casacore::RecordGramVal | Helper class for values in RecordGram |
| casacore::RecordInterface | Abstract base class for Record classes |
| casacore::RecordNotice | Helper class to notify class Record about changes |
| casacore::RecordRep | The representation of a Record |
| casacore::RecordTransformable | Interface class for converting to/from records |
| casa::viewer::Rectangle | All regions are specified in "linear coordinates", not "pixel coordinates" |
| casa::RectRegionEvent | Contains info on the WC rectanglar area selected by MWCRTRegion mouse tool |
| casacore::RefColumn | A column in a reference table |
| casacore::MeasRef< Ms >::RefRep | Representation class |
| casacore::RefRows | Class holding the row numbers in a RefTable |
| casacore::RefRowsSliceIter | Class to iterate through a RefRows object |
| casacore::RefTable | Class for a table as a view of another table |
| casacore::Regex | Regular expression class |
| casacore::RegexBase | Abstract interface class to regular expressions for String |
| casa::viewer::Region | All regions are specified in "linear coordinates", not "pixel coordinates" |
| casa::RegionBox | |
| casa::viewer::RegionCreator | |
| casacore::RegionHandler | Base class for handling regions in images |
| casacore::RegionHandlerHDF5 | Class for keeping regions in an HDF5 file |
| casacore::RegionHandlerMemory | Class for keeping regions in memory |
| casacore::RegionHandlerTable | Class for keeping regions in memory |
| casa::viewer::RegionInfo | |
| casacore::RegionManager | |
| casa::RegionShape | Parent class for all RegionShapes |
| casa::RegionShapeDM | Implementation of CachingDisplayMethod to be used by RegionShapes |
| casa::RegionShapeLabel | Text label associated with a RegionShape |
| casa::viewer::RegionSource | |
| casa::viewer::RegionSourceFactory | |
| casa::viewer::RegionSourceKernel | |
| casa::RegionTextList | An ordered list of annotations and comments representing an ascii region file. <author>Dave Mehringer</author> |
| casa::RegionTextParser | Parse and store regions and annotations from an ascii region file <author>Dave Mehringer</author> |
| casa::RegionTool | |
| casa::viewer::RegionToolManager | RegionCreator class now has static members which allow for the retrieval of lists of RegionCreator objects for creating each type of region (currently rectangle, polygon, ellipse, and point) |
| casacore::RegionType | Define the various region types |
| casacore::Register_global_functions_register | Primitive Run Time Type Information (RTTI) |
| casa::vi::RegriddingKernel | |
| casa::vi::RegriddingTransformEngine< T > | |
| casa::vi::RegriddingTVI | |
| casa::vi::RegriddingTVIFactory | |
| casacore::RegSequence | Sequence for the Register() template functions |
| casacore::RegularFile | Manipulate and get information about regular files |
| casacore::RegularFileIO | Class for IO on a regular file |
| asdm::Representable | The Representable interface is implemented by all tables and by the container |
| casa::ResamplerWorklet | |
| casacore::ReservedFitsKeyword | Reserved FITS keyword |
| casacore::ReservedFitsKeywordCollection | Collection of reserved FITS keywords |
| casa::ResetCrosshairEvent | Event sent to tell MWCCrosshairTool to reset |
| casa::ResetRTRegionEvent | Event sent to tell MWCRTRegionTool to reset |
| casa::ResidualAlgorithm | Parallel residual image formation |
| casa::ResidualEquation< Domain > | Interface class containing functions returning "Domain" type |
| casa::ResidualHistogramDialog | |
| casa::Result | Convenience class for a String/bool tuple |
| casacore::RetypedArrayEngine< VirtualType, StoredType > | Virtual column engine to retype and reshape arrays |
| casacore::RetypedArraySetGet_global_functions_RetypedArrayEngineSetGet | Helper functions for users of RetypedArrayEngine |
| casa::Reweighter | |
| casa::RFABase | Abstract RedFlagger Agent base class |
| casa::RFADiffBase | RFADiffBase: abstract class for deviation-based flagging |
| casa::RFADiffMapBase | Abstract base class for deviation-based flagging with a data mapper |
| casa::RFAFlagCubeBase | Abstract RedFlagger Agent class with a flag cube |
| casa::RFAFlagExaminer | RFAFlagExaminer: Examine the flags and get statistics. perform extensions too |
| casa::RFAFreqMedian | RFAFreqMedian: RedFlagger Agent for clipping relative to median over frequency |
| casa::RFANewMedianClip | RFANewMedianClip:RedFlagger Agent;clips relative to median over time slots |
| casa::RFASelector | RFASelector: flags pixels/rows based on a specified selection |
| casa::RFASpectralRej | RFASpectralRej: Spectral rejection agent |
| casa::RFATimeFreqCrop | RFATimeFreqCrop : 2-Dimensional Time Frequency Autoflag agent |
| casa::RFATimeMedian | RFATimeMedian: RedFlagger Agent for clipping relative to median over time |
| casa::RFAUVBinner | RFAUVBinner: flagging via UV binning |
| casa::RFChunkStats | RFChunkStats: vital information and flagging stats for a visibility chunk |
| casa::RFCubeLattice< T > | RFCubeLatice: a cubic lattice |
| casa::RFCubeLatticeIterator< T > | |
| casa::RFDataMapper | RFDataMapper: maps complex visibilities to a single real value |
| casacore::RFError | Convenience class for a String/bool pair |
| casa::RFError | Convenience class for a String/bool pair |
| casa::RFFlagCube | RFFlagCube: a cube of flags |
| casa::RFFloatLattice | RFFloatLatice: a cubic lattice |
| casa::RFFloatLatticeIterator | |
| casacore::RFReader | Abstract superclass for any class that reads a format that produces Regions from a file |
| casacore::RFReaderWriter | Superclass for readers and writers containing common definitions and operations |
| casa::RFRowClipper | RFRowClipper: flags rows based on their noise level |
| casacore::RFWriter | Abstract superclass for any class that writes Regions to a region file format |
| casa::rGridFT | An FTMachine for Gridded Fourier transforms |
| casacore::RigidVector< T, n > | Fast Vector classes with fixed (templated) length |
| casacore::RigidVector_global_functions_math | Mathematical operations involving RigidVectors |
| casa::RIorAPArray | |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::RmsFunc< T > | |
| casacore::RNG | Base class for random number generators |
| casacore::RO_LatticeIterator< T > | A readonly iterator for Lattices |
| casacore::RO_MaskedLatticeIterator< T > | A readonly iterator for masked Lattices |
| casa::ROBJonesMCol | ROBJonesMCol: Read-only BJones cal_main column access |
| casa::ROBJonesPolyMCol | ROBJonesPolyMCol: Read-only BJonesPoly cal_main column access |
| casa::ROCalDescColumns | ROCalDescColumns: Read-only cal_desc calibration table column access |
| casa::ROCalDescColumns2 | ROCalDescColumns: Read-only cal_desc calibration table column access |
| casa::ROCalHistoryColumns | ROCalHistoryColumns: Read-only cal_history calibration table column access |
| casa::ROCalMainColumns | ROCalMainColumns: Read-only cal_main calibration table column access |
| casa::ROCalMainColumns2< T > | |
| casa::ROCJonesMCol | ROCJonesMCol: Read-only CJones cal_main column access |
| casa::ROCTColumns | A class to provide easy read-only access to new CalTable columns |
| casa::ROCTIter | ROCTIter: Read-only iterating interface to New Calibration tables |
| casa::ROCTMainColumns | |
| casacore::RODataManAccessor | Base class for the Data Manager Accessor classes |
| casa::RODJonesMCol | RODJonesMCol: Read-only DJones cal_main column access |
| casa::ROEPointMCol | |
| casa::ROGJonesMCol | ROGJonesMCol: Read-only GJones cal_main column access |
| casa::ROGJonesPolyMCol | ROGJonesPolyMCol: Read-only GJonesPoly cal_main column access |
| casa::ROGJonesSplineMCol | ROGJonesSplineMCol: Read-only GJonesSpline cal_main column access |
| casa::ROGroupWorker | ROGroupWorkers process VisBuffGroups without modifying the input MS(es) |
| casacore::ROIncrementalStManAccessor | Give access to some IncrementalStMan functions |
| casacore::ROMSAntennaColumns | A class to provide easy read-only access to MSAntenna columns |
| casacore::ROMSColumns | A class to provide easy read-only access to MeasurementSet columns |
| casacore::ROMSDataDescColumns | A class to provide easy read-only access to MSDataDesc columns |
| casacore::ROMSDopplerColumns | A class to provide easy read-only access to MSDoppler columns |
| casacore::ROMSFeedColumns | A class to provide easy read-only access to MSFeed columns |
| casacore::ROMSFieldColumns | A class to provide easy access to MSField columns |
| casacore::ROMSFlagCmdColumns | A class to provide easy read-only access to MSFlagCmd columns |
| casacore::ROMSFreqOffsetColumns | A class to provide easy read-only access to MSFreqOffset columns |
| casacore::ROMSHistoryColumns | A class to provide easy read-only access to MSHistory columns |
| casacore::ROMSMainColumns | A class for easy read-only access to MeasurementSet main table columns |
| casacore::ROMSObservationColumns | A class to provide easy read-only access to MSObservation columns |
| casacore::ROMSPointingColumns | A class to provide easy read-only access to MSPointing columns |
| casacore::ROMSPolarizationColumns | A class to provide easy read-only access to MSPolarization columns |
| casacore::ROMSProcessorColumns | A class to provide easy read-only access to MSProcessor columns |
| casacore::ROMSSourceColumns | A class to provide easy read-only access to MSSource columns |
| casacore::ROMSSpWindowColumns | A class to provide easy read-only access to MSASpectralWindow columns |
| casacore::ROMSStateColumns | A class to provide easy read-only access to MSState columns |
| casacore::ROMSSysCalColumns | A class to provide easy read-only access to MSSysCal columns |
| casacore::ROMSWeatherColumns | A class to provide easy read-only access to MSWeather columns |
| casa::ROPJonesMCol | ROPJonesMCol: Read-only PJones cal_main column access |
| casacore::RORecordFieldPtr< T > | Read-Only access to an individual field from a Record |
| casa::ROSolvableCalSetMCol< T > | ROSolvableVisJonesMCol: Read-only SolvableVisJones cal_main column access |
| casa::ROSolvableVisJonesMCol | ROSolvableVisJonesMCol: Read-only SolvableVisJones cal_main column access |
| casacore::ROStandardStManAccessor | Give access to some StandardStMan functions |
| casacore::ROTableRow | Readonly access to a table row |
| casacore::ROTiledStManAccessor | Give access to some TiledStMan functions |
| casa::ROTimeVarVisJonesMCol | ROTimeVarVisJonesMCol: Read-only TimeVarVisJones cal_main column access |
| casa::ROTJonesMCol | ROTJonesMCol: Read-only TJones cal_main column access |
| casa::ROTJonesPolyMCol | ROTJonesPolyMCol: Read-only TJonesPoly cal_main column access |
| casa::ROTJonesSplineMCol | ROTJonesSplineMCol: Read-only TJonesSpline cal_main column access |
| casacore::RotMatrix | A 3x3 rotation matrix |
| casacore::Round< T, RES > | Functor to apply round (e.g |
| casa::asyncio::RoviaModifier | |
| casa::vi::RoviaModifier | |
| casa::asyncio::RoviaModifiers | |
| casa::vi::RoviaModifiers | |
| casa::ROVisibilityIterator | ROVisibilityIterator iterates through one or more readonly MeasurementSets |
| casa::ROVisIterator | |
| casa::ROVisJonesMCol | ROVisJonesMCol: Read-only VisJones cal_main calibration table column access |
| casa::QtPlotSvrPanel::row_desc | |
| casa::vi::VisibilityIteratorImpl2::RowBounds | |
| casacore::RowCopier | RowCopier copies all or part of a row from one table to another |
| rowsInAScanbyTimeFunctor< T > | |
| rowsInAScanbyTimeIntervalFunctor< T > | |
| asdm::RowTransformer< RowClass > | |
| casa::RSCircle | Subclass of RSEllipse used for drawing circles |
| RSComposite | Subclass of RegionShape used for drawing composite regions |
| casa::RSEllipse | Subclass of RegionShape used for drawing ellipses |
| casa::RSFileReader | Abstract superclass for any class that reads a format that produces RegionShapes from a file |
| casa::RSFileReaderWriter | Superclass for readers and writers containing common definitions and operations |
| casa::RSFileWriter | Abstract superclass for any class that writes RegionShapes to a region file format |
| casa::RSHandle | A "handle" is a four-point structure (usually a rectangle) that describes the boundaries in screen pixels that a RegionShape takes on a canvas |
| casa::RSLine | Subclass of RegionShape used for drawing lines |
| RSMarker | Subclass of RegionShape used for drawing markers |
| casa::RSOption | Convenience class for a String, bool, or double |
| casa::RSPolygon | Subclass of RegionShape used for drawing polygons |
| casa::RSRectangle | Subclass of RegionShape used for drawing rectangles |
| RSText | Subclass of RegionShape used for drawing text |
| casa::RSUtils | Common utilities/constants for region shapes |
| casa::RSValue | Convenience class for the different units available for coordinates/sizes |
| RSVector | Subclass of RSLine that takes a length and angle instead of a second point |
| casa::RSXML | Constants and methods for reading/writing RS XML files |
| casa::viewer::runtime_error | |
| casa::utilj::RUsage | |
| s_overTheTop | A structure to define a range of rows in the Pointing table where the attribute overTheTop is defined and with which value |
| casacore::SampledFunctional< Range > | A base class for indexing into arbitrary data types |
| casa::SaveHistogramWidget | |
| asdm::SBSummaryRow | Row of a SBSummaryTable |
| asdm::SBSummaryTable | Alma table |
| casacore::ScalarColumn< T > | Access to a scalar table column with arbitrary data type |
| casacore::ScalarColumnData< T > | Access to a table column containing scalars |
| casacore::ScalarColumnDesc< T > | Templated class to define columns of scalars in tables |
| casacore::ScalarFITSFieldCopier< recordType, fitsType > | A FITSFieldCopier for copying scalar non-string RecordFields to FitsFields |
| casacore::ScalarMeasColumn< M > | Read only access to table scalar Measure columns |
| casacore::ScalarQuantColumn< T > | Provides access to Scalar Quantum Columns in Tables |
| casacore::ScalarRecordColumnData | Access to a table column containing scalar records |
| casacore::ScalarRecordColumnDesc | Class to define columns of scalar records in tables |
| casacore::ScalarSampledFunctional< T > | A unified interface for indexing into Vectors or Blocks |
| casacore::ScaledArrayEngine< VirtualType, StoredType > | Templated virtual column engine to scale a table array |
| casacore::ScaledComplexData< VirtualType, StoredType > | Templated virtual column engine to scale a complex table array |
| asdm::ScaleRow | Row of a ScaleTable |
| asdm::ScaleTable | Alma table |
| casacore::ScanKey | A scan is a unique combination of observation ID, array ID, and scan number Negative values are allowed to indicate all values of the particular ID are desired |
| casacore::MSMetaData::ScanProperties | |
| asdm::ScanRow | Row of a ScanTable |
| asdm::ScanTable | Alma table |
| casa::Scantable2MSReader | |
| casa::ScantableFieldIterator | |
| casa::ScantableFrequenciesIterator | |
| casa::ScantableIteratorInterface | |
| casa::ScantableSourceIterator | |
| casa::ScatterPlot | Scatter plot abstract class |
| casacore::ScopedMutexLock | Exception-safe lock/unlock of a mutex |
| casa::ScrollingRasterDD | |
| casa::ScrollingRasterDM | Base class for scrolling DisplayData objects |
| casacore::SCSL | C++ Interface to the Sgi/Cray Scientific Library (SCSL) |
| casa::SDAlgorithmAAspClean | |
| casa::SDAlgorithmBase | |
| casa::SDAlgorithmClarkClean | |
| casa::SDAlgorithmClarkClean2 | |
| casa::SDAlgorithmHogbomClean | |
| casa::SDAlgorithmMEM | |
| casa::SDAlgorithmMSClean | |
| casa::SDAlgorithmMSMFS | |
| casa::SDAlgorithmTest | |
| casacore::SDAntennaHandler | |
| casa::SDBList | |
| casacore::SDDataDescHandler | |
| casa::SDDataSampling | Provides sampling of single dish data for esimation algorithms |
| casa::SDDoubleCircleGainCal | |
| casa::SDDoubleCircleGainCalImpl | |
| casacore::SDFeedHandler | |
| casacore::SDFieldHandler | |
| casacore::SDFITSHandler | |
| casacore::SDFITSTable | SDFITSTable is a FITSTable which follows the Single Dish FITS Convention |
| casa::SDGrid | An FTMachine for Gridding Single Dish data |
| casacore::SDHistoryHandler | |
| casacore::SDMainHandler | |
| casa::SDMaskHandler | |
| sdmbin::SDMBinData | Accessor to the SDM binary data |
| sdmbin::SDMData | A structure containing the data from a single SDM BLOB (origin: version for TP FBT, FV 12 Avril 2007) with the view of one row in the SDM Main table |
| asdmbinaries::SDMDataObject | SDMDataObject:: declarations |
| asdmbinaries::SDMDataObjectException | A class to represent an exception thrown during an access to an SDMDataObject |
| asdmbinaries::SDMDataObjectParser | |
| asdmbinaries::SDMDataObjectParserException | A class to represent an exception thrown during the parsing of an XML header in a MIME message containing ALMA binary data |
| asdmbinaries::SDMDataObjectReader | A class to read a MIME message containing ALMA binary data and provide a view on these binary data through an instance of SDMDataObject |
| asdmbinaries::SDMDataObjectReaderException | A class to represent an exception thrown while reading a MIME message containing ALMA binary data |
| asdmbinaries::SDMDataObjectStreamReader | |
| asdmbinaries::SDMDataObjectStreamReaderException | |
| asdmbinaries::SDMDataObjectWriter | A general class to write MIME messages containing ALMA binary data |
| asdmbinaries::SDMDataObjectWriterException | A class to represent an exception thrown while writing a MIME message containing ALMA binary data |
| asdmbinaries::SDMDataSubset | SDMDataObject:: |
| casa::SDMSManager | |
| casacore::SDObservationHandler | |
| casacore::SDPointingHandler | |
| casacore::SDPolarizationHandler | |
| casa::SDPosInterpolator | |
| casacore::SDSourceHandler | |
| casacore::SDSpWindowHandler | |
| casacore::SDSysCalHandler | |
| casacore::SDWeatherHandler | |
| casa::SearchEngine | Performs a query on a splatalogue spectral line table |
| casa::Searcher | Interface needed to support molecular line searching and identification |
| casa::SearcherFactory | |
| casa::SearcherSQLite | Searches a local sqlite database for molecular lines meeting the specified search criteria |
| casa::SearchMoleculesDialog | |
| casa::SearchMoleculesResultDisplayer | Interface provides decoupling between classes that initialize a search such as SearchMoleculesWidget and classes that display the results of a search such as SearchMoleculesResultsWidget |
| casa::SearchMoleculesResultsWidget | |
| casa::SearchMoleculesWidget | |
| casa::SearchRedshiftDialog | |
| casa::SearchThread | Responsible for running the search algorithm in the background so that we don't freeze the GUI |
| casa::utilj::SecondFunctor< F, S > | |
| asdm::SeeingRow | Row of a SeeingTable |
| asdm::SeeingTable | Alma table |
| casa::RFASpectralRej::Segment | Spectral region specifications |
| casa::SegmentTracer | |
| use::SelectAverageSpw | |
| casa::asyncio::SelectChannelModifier | |
| casa::vi::SelectChannelModifier | |
| casa::asyncio::SelectVelocityModifier | |
| casa::vi::SelectVelocityModifier | |
| casa::async::Semaphore | |
| casacore::LSQFit::Separable | |
| casa::SepImageConvolver< T > | This class does separable convolution of an image |
| casa::SepImageConvolverTask< T > | This class is the high level interface to image convolving |
| casacore::Sequence< t > | Virtual templated base class for sequences |
| casacore::SerialHelper | |
| casa::SerialPartitionMixin< T > | Parameter and input data partitioning for serial imaging (in ParallelImagerMixin) |
| casa::SerialTransport | Putting in the MPI Transport stuff only makes sense if we have MPI |
| casa::ServiceProxy | |
| casa::asyncio::SetIntervalModifier | |
| casa::vi::SetIntervalModifier | |
| casa::refim::SetJyGridFT | An FTMachine for Gridded Fourier transforms specializing in setjy frequency scaling |
| casa::SetJyGridFT | An FTMachine for Gridded Fourier transforms specializing in setjy frequency scaling |
| casa::vi::SetRowBlockingModifier | |
| casa::asyncio::SetRowBlockingModifier | |
| casa::SettingsWidget | |
| casacore::SetupNewTable | Create a new table - define shapes, data managers, etc |
| casacore::SetupNewTableRep | Representation for handle class SetupNewTable |
| asdm::Short | A collection of static methods to perform conversions between strings and short integer values |
| casa::SigHandler | |
| casacore::Sign< T, RES > | Functor to apply sign (result is -1, 0, or 1) |
| casa::SIImageStore | |
| casa::SIImageStoreMultiTerm | |
| casa::SIIterBot_adaptor | |
| casa::SIIterBot_callback | |
| casa::SIIterBot_state | |
| casa::SimACoh | SimACoh: Model additive noise errors for the VisEquation |
| casa::SimACohCalc | SimACohCalc: Model additive noise errors for the VisEquation |
| casa::refim::SIMapper | |
| casa::SIMapper | Class that contains functions needed for imager |
| casa::refim::SIMapperCollection | |
| casa::SIMapperCollection | |
| casa::SIMapperImageMosaic | Class that contains functions needed for imager |
| casa::refim::SIMapperImageMosaic | Class that contains functions needed for imager |
| casacore::SimButterworthBandpass< T > | Class for evaluating a Butterworth filter transfer function |
| casa::SIMinorCycleController | |
| casacore::SimOrdMapIO_global_functions_inoutput | Global IO functions |
| casa::SimpComponentGridMachine | SimpComponentFTMachine: does the simplest Fourier transform on SkyComponents |
| casa::SimpleComponentFTMachine | |
| casa::refim::SimpleComponentFTMachine | Does the simplest Fourier transform on SkyComponents |
| casa::SimpleComponentGridMachine | |
| casacore::SimpleOrderedMap< K, V > | Simple map with keys ordered |
| casa::SimplePBConvFunc | |
| casa::refim::SimplePBConvFunc | |
| casa::SimplePlotter | SimplePlotter is a concrete class that uses the abstract plotting classes to perform common tasks |
| casa::vi::SimpleSimVi2 | |
| casa::vi::SimpleSimVi2Factory | |
| casa::vi::SimpleSimVi2LayerFactory | |
| casa::vi::SimpleSimVi2Parameters | |
| casa::SimpleSubMS | SimpleSubMS provide a simpler subset of SubMS. The purpose of this class to avoid unnecessary IO for some simplistic selection and subMSsing No averaging no fanciness...simple time and channel subsets |
| casa::Simulator | Simulates MeasurementSets from SkyModel and SkyEquation |
| casacore::Sin< T, RES > | Functor to apply sin |
| casacore::Sinc_Conv< T > | Sine x / x function |
| casacore::SincFunction< T > | A one dimensional sin(x)/x |
| casacore::SincParam< T > | A one dimensional sin(x)/x |
| casa::SingleDishMS | |
| casa::SingleDishMSFiller< Reader > | |
| casa::SingleDishOtfCal | |
| casa::SingleDishPositionSwitchCal | |
| casa::SingleDishRasterCal | |
| casa::SingleDishSkyCal | |
| casacore::Sinh< T, RES > | Functor to apply sinh |
| casacore::Sinusoid1D< T > | A one dimensional Sinusoid class |
| casacore::Sinusoid1D_PS< AutoDiff< T > > | Partial specialization of Sinusoid1D for AutoDiff |
| casacore::Sinusoid1DParam< T > | Parameter handling for one dimensional Sinusoid class |
| size_lt< T > | A boolean template functor which returns the value of the expression x.size() < y |
| casa::SkyCal< DataType, CalDataType > | |
| casa::SkyCatOverlayDD | Simple implementation of a cached DisplayData for sky catalogue overlays |
| casa::SkyCatOverlayDM | Class to draw catalogue overlays for SkyCatOverlayDD |
| casa::SkyCompBase | Base class for model components of the sky brightness |
| casa::SkyComponent | A component of a model of the sky |
| casa::SkyComponentFactory | |
| casa::SkyCompRep | A model component of the sky brightness |
| casa::SkyEquation | |
| casa::SkyJones | Sky Jones: Model sky-plane instrumental effects for the SkyEquation |
| casa::refim::SkyJones | Sky Jones: Model sky-plane instrumental effects for the SkyEquation |
| casa::SkyJonesDesc | SkyJonesDesc: Define the format of SkyJones calibration tables |
| casa::SkyModel | Sky Model: Model the Sky Brightness for the SkyEquation |
| casacore::Slice | Define a (start,length,increment) along an axis |
| casa::SliceAxisDraw | Overriding QwtScaleDraw in order to provide custom (smaller) fonts for the tick labels on a plot axis |
| casa::SliceColorPreferences | |
| casa::SliceEH | An event handler to negotiate between three different PanelDisplays |
| casa::SlicePanelDisplay | An application provide displays of three axis combinations of data in a cube |
| casa::SlicePlot | |
| casa::SlicePlotPreferences | |
| casacore::Slicer | Specify which elements to extract from an n-dimensional array |
| casacore::Slicer_global_functions_Slicer_IO | IO functions for Slicer's |
| casa::viewer::SliceRegionInfo | |
| casa::viewer::SlicerGen | |
| casa::SlicerMainWindow | |
| casa::SliceSegment | |
| casa::SliceStatistics | Computes the angle and distance for a single line segment in the slice |
| casa::SliceStatisticsDistance | |
| casa::SliceStatisticsFactory | Returns SliceStatistics appropriate to what is displayed on the x-axis and the units being used |
| casa::SliceStatisticsPosition | |
| casa::viewer::qt::SliceStats | |
| casa::SliceWorker | Responsible for computing the (x,y)-values that represent a slice cut |
| casa::SliceZoomer | |
| casa::SlideEditor | |
| casa::SLog | |
| casacore::Smooth< T > | Smooth a Vector or the rows of a 2D Array taking into account flags which are supplied in a Vector/Array of the same shape. Modify the flags as necessary to mark channels for which the smoothing could not be done because needed channels were flagged |
| casa::SmoothPreferences | |
| casa::SmoothSpinBox | Adds non-editability to a standard QSpinBox |
| casacore::SolarPos | Solar position class and calculations |
| casa::SolvableCalSetMCol< T > | SolvableCalSetMCol: RW SolvableCalSet cal_main column access |
| casa::SolvableMJonesDesc | SolvableMJonesDesc: Define the format of SolvableMJones cal tables |
| casa::SolvableMJonesMRec | SolvableMJonesMRec: SolvableMJones cal_main table record access/creation |
| casa::SolvableVisCal | |
| casa::SolvableVisJones | ********************************************************** SolvableVisJones |
| casa::SolvableVisJonesDesc | SolvableVisJonesDesc: Define the format of SolvableVisJones cal tables |
| casa::SolvableVisJonesMBuf | SolvableVisJonesMBuf: SolvableVisJones calibration main table buffer |
| casa::SolvableVisJonesMCol | SolvableVisJonesMCol: RW SolvableVisJones cal_main column access |
| casa::SolvableVisJonesMRec | SolvableVisJonesMRec: SolvableVisJones cal_main table record access/creation |
| casa::SolvableVisJonesTable | SolvableVisJonesTable: SolvableVisJones calibration table access/creation |
| casa::SolvableVisMueller | ********************************************************** SolvableVisMueller |
| casa::SolveDataBuffer | SolveDataBuffer is a container for VisBuffer2 data and related residual and differentiation results related to generic calibration solving |
| casacore::Sort | Sort on one or more keys, ascending and/or descending |
| casa::vi::SortColumns | |
| casacore::SortError | Generic Sort exception |
| casacore::SortInvDT | Invalid data type used for this sort key |
| casacore::SortInvIncr | Invalid increment used for this sort key |
| casacore::SortInvOpt | Invalid sort option given to routine dosort |
| casacore::SortKey | Define a Sort key |
| casacore::SortNoData | No data array given to Sort constructor |
| casacore::SourceKey | Primary key in the SOURCE table |
| casacore::LogOrigin_global_functions_SourceLocation::SourceLocation | |
| casacore::MSMetaData::SourceProperties | Non-primary key data for a SOURCE table row |
| casa::sdfiller::SourceRecord | |
| asdm::SourceRow | Row of a SourceTable |
| asdm::SourceTable | Alma table |
| casacore::SparseDiff< T > | Class that computes partial derivatives by automatic differentiation |
| casacore::SparseDiffA< T > | Class that computes partial derivatives by automatic differentiation |
| casacore::SparseDiffIO_global_functions_SparseDiff_IO_operations | Implements all IO operators and functions for SparseDiff |
| casacore::SparseDiffMath_global_functions_SparseDiff_mathematical_operations | Implements all mathematical operators and functions for SparseDiff |
| casacore::SparseDiffRep< T > | Representation of data for the spare automatic differentiation calss |
| casacore::SparseDiffX< T > | Class that computes partial derivatives by automatic differentiation |
| casa::SpecFit | |
| casa::SpecFitGaussian | |
| casa::SpecFitLogDialog | |
| casa::SpecFitPolynomial | |
| SpecFitSettingsFixedTableCell | |
| casa::SpecFitSettingsWidgetOptical | |
| casa::SpecFitSettingsWidgetRadio | |
| casacore::SpecificFunctionFactory< T, F > | |
| casa::QtProfile::spectra_info | |
| casa::ms::SpectralChannel | |
| casa::SpectralCollapser | |
| casacore::SpectralCoordinate | Interconvert pixel and frequency values |
| casa::SpectralElement | Describes (a set of related) spectral lines |
| casa::SpectralElementFactory | FIXME fix documentation |
| casa::SpectralEstimate | Get an initial estimate for spectral lines |
| casa::SpectralFit | Least Squares fitting of spectral elements to spectrum |
| casa::SpectralFitter | |
| casa::SpectralImageUtil | |
| casa::SpectralIndex | Models the spectral variation with a spectral index |
| casa::SpectralList | A set of SpectralElements |
| casa::SpectralList_global_functions_Output | Global functions |
| casa::SpectralListFactory | Create a SpectralList |
| casa::SpectralModel | Base class for spectral models |
| casa::SpectralPositioningWidget | |
| asdmbinaries::SDMDataObject::SpectralWindow | SDMDataObject::SpectralWindow:: declarations |
| casa::ms::SpectralWindow | |
| casa::sdfiller::SpectralWindowRecord | |
| asdm::SpectralWindowRow | Row of a SpectralWindowTable |
| casa::ms::SpectralWindows | |
| asdm::SpectralWindowTable | Alma table |
| asdm::Speed | Implements a quantity of speed in meters per second |
| casacore::Sph_Conv< T > | Spheroidal function |
| casa::SplatalogueTable | Representation of a Splatalogue Table |
| casa::SplatResult | |
| casa::vpf::SplitterVp | Class SimpleVp: public VisibilityProcessor { |
| casacore::SPolynomial< T > | A one dimensional scaled polynomial class |
| casacore::SPolynomialParam< T > | Parameter handling for scaled 1-D polynomials |
| SPtrHolder< T > | Hold and delete pointers not deleted by object destructors |
| casa::CalAnalysis::SPW_INFO | SPW_INFO nested class |
| casa::spwInfo | |
| casacore::MSMetaData::SpwProperties | |
| casacore::Sqr< T, RES > | Functor to apply sqr (power of 2) |
| casacore::Sqrt< T, RES > | Functor to apply sqrt |
| asdm::SquareLawDetectorRow | Row of a SquareLawDetectorTable |
| asdm::SquareLawDetectorTable | Alma table |
| casacore::SquareMatrix< T, n > | Fast Square Matrix class with fixed (templated) size |
| casacore::SquareMatrix_global_functions_SqM_global_functions | Various global math and IO functions |
| casacore::SSMBase | Base class of the Standard Storage Manager |
| casacore::SSMColumn | A Column in the Standard Storage Manager |
| casacore::SSMDirColumn | A Direct Array Column in the Standard Storage Manager |
| casacore::SSMIndColumn | A column of Standard storage manager for indirect arrays |
| casacore::SSMIndex | The bucket index for a group of columns in the Standard Storage Manager |
| casacore::SSMIndStringColumn | An Indirect String Array Column in the Standard Storage Manager |
| casacore::SSMStringHandler | Store strings in the Standard Storage Manager |
| casacore::Stack< elem > | This class, Stack<t>, defines an implementation of a stack using the doubly linked list primitive, Link<t> |
| casacore::StandardStMan | The Standard Storage Manager |
| casa::StandardTsys | Not yet: class TJonesCorruptor; |
| casa::Star | Simple class which represents a star as a point mass |
| casacore::StatAcc< T > | A statistics accumulator |
| casa::RegionTool::State | |
| casa::display::state | |
| casa::display::stateCleanup | |
| asdm::StateRow | Row of a StateTable |
| asdm::StateTable | Alma table |
| asdm::StationRow | Row of a StationTable |
| asdm::StationTable | Alma table |
| casacore::StatisticsAlgorithm< AccumType, DataIterator, MaskIterator, WeightsIterator > | Base class of statistics algorithm class hierarchy |
| casacore::StatisticsData | |
| casacore::StatisticsIncrementer< DataIterator, MaskIterator, WeightsIterator > | Utility functions used for incrementing pointers in a data set used by the stats framework |
| casacore::StatisticsUtilities< AccumType > | Various statistics related methods for the statistics framework |
| casa::viewer::qt::stats_t | |
| casacore::StatsData< AccumType > | |
| casacore::StatsDataProvider< AccumType, DataIterator, MaskIterator, WeightsIterator > | Abstract base class which defines interface for providing "datasets" to the statistics framework when nontrivial means of doing so are not sufficient |
| casacore::StatsTiledCollapser< T, U > | Generate statistics, tile by tile, from a masked lattice NOTE this version was moved from LatticeStatistics (early Dec 2014 version) and slightly modified mostly for style issues (no significant semantic differences from that version). For a large number of statistics sets that need to be computed simultaneously, this version is more efficient than using the new stats framework, because creating large numbers of eg ClassicalStatistics objects is much less efficient than the direct manipulation of pointers to primitive types that this class does |
| casa::viewer::StatusSink | |
| casa::StatWT | StatWT sets WEIGHT and SIGMA statistically |
| casacore::std11_allocator< T > | |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::StddevFunc< T > | |
| casa::SteepestDescentSolver | |
| casacore::StIndArray | Read/write indirect arrays |
| casacore::STLMath_global_functions_Container_Math | Math operations on STL-like containers |
| casacore::StManAipsIO | AipsIO table storage manager class |
| casacore::StManArrayFile | Read/write array in external format for a storage manager |
| casacore::StManColumn | Base table column storage manager class |
| casacore::StManColumnAipsIO | AipsIO table column storage manager class |
| casacore::StManColumnArrayAipsIO | AipsIO storage manager for direct table arrays |
| casacore::StManColumnIndArrayAipsIO | AipsIO storage manager for indirect table arrays |
| casacore::Stokes | Stokes parameter definitions for interface to table data |
| casacore::StokesConverter | StokesConverter converts any set of polarizations into any other one |
| casacore::StokesCoordinate | Interconvert between pixel and Stokes value |
| casa::StokesImageUtil | |
| casa::StokesUtil_global_functions_StokesVector_ancillary_Functions | For use with StokesVectors and related classes |
| casa::StokesVector | |
| casacore::StorageOption | Options defining how table files are organized |
| casacore::StreamIO | Class for IO on connection oriented socket |
| casacore::StreamLogSink | Send log messages to an ostream |
| casacore::String | String: the storage and methods of handling collections of characters |
| casacore::String_global_functions_case | Casing and related functions Case conversion and rearrangement functions |
| casacore::String_global_functions_common | Some general functions Functions to find special patterns, join and replicate |
| casacore::String_global_functions_comparitor | Global comparison operators |
| casacore::String_global_functions_concatenator | Global concatenation operators |
| casacore::String_global_functions_io | IO |
| casacore::String_global_functions_split | Splitting Global function which splits the String into string array res at separator and returns the number of elements |
| casacore::StringDistance | Class to deal with Levensthein distance of strings |
| casacore::StringFITSFieldCopier | A FITSFieldCopier for copying String RecordFields to FitsFields |
| casa::utilj::Strings | |
| asdm::StringTokenizer | Translation into C++ of the Java class of the same name in Java's util pacakge |
| casa::QtRasterData::structMinMax | |
| casa::QtRasterData::structXY | |
| casa::vpf::SubchunkIndex | |
| casa::SubChunkPair | |
| casacore::SubImage< T > | A (masked) subset of an ImageInterface object |
| casa::SubImageFactory< T > | Static methods for subimage creation |
| sdmbin::Subintegration | The class Subintegration extends the DataDump by adding two attributes the integration number and the subintegration number |
| casacore::SubLattice< T > | A subset of a Lattice or MaskedLattice |
| casacore::SubScanKey | A sub scan is a unique combination of observation ID, array ID, scan number, and field ID |
| casacore::MSMetaData::SubScanProperties | |
| asdm::SubscanRow | Row of a SubscanTable |
| asdm::SubscanTable | Alma table |
| casacore::SubString | SubString help class to be used in at, before, ..\ |
| casa::vi::SubtableColumns | |
| casacore::SubTableDesc | Description of columns containing tables |
| casacore::SumAbsDiff< T, Accum > | Functor to add absolute diff of right and base value to left |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::SumFunc< T > | Define functors to perform a reduction function on an Array object |
| casa::FlagAgentSummary::summary | |
| casacore::SumSqr< T, Accum > | Functor to add square of right to left |
| casacore::SumSqrDiff< T, Accum > | Functor to add squared diff of right and base value to left |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::SumSqrFunc< T > | |
| casa::asyncio::VLAT::SweepTerminated | |
| casa::vi::VLAT::SweepTerminated | |
| asdm::SwitchCycleRow | Row of a SwitchCycleTable |
| sdmbin::SwitchCyclesList | Definition of the root of the tree hierarchy |
| asdm::SwitchCycleTable | Alma table |
| casacore::SymLink | Get information about, and manipulate symbolic links |
| casa::SynDataSampling | Provides sampling of synthesis data for estimation algorithms |
| casa::SynthesisDeconvolver | Class that contains functions needed for imager |
| casa::SynthesisDeconvolverMixin< T > | Simple mixin class to put SynthesisDeconvolver into ParallelImagerMixin framework |
| casa::SynthesisError | |
| casa::SynthesisFTMachineError | Error thrown by the classes in the Synthesis module |
| casa::SynthesisImager | Class that contains functions needed for imager |
| casa::refim::SynthesisImager | |
| casa::SynthesisImagerMixin< T > | Simple mixin class to put SynthesisImager into ParallelImagerMixin framework |
| casa::SynthesisImagerVi2 | |
| casa::SynthesisIterBot | Class that contains functions needed for imager |
| casa::SynthesisIterBotWithOldGUI | |
| casa::SynthesisNormalizer | Class that contains functions needed for imager |
| casa::SynthesisNormalizerMixin< T > | Simple mixin class to put SynthesisNormalizer into ParallelImagerMixin framework |
| casa::SynthesisParams | |
| casa::SynthesisParamsDeconv | |
| casa::SynthesisParamsGrid | |
| casa::SynthesisParamsImage | |
| casa::SynthesisParamsSelect | |
| casa::SynthesisUtilMethods | |
| casa::sdfiller::SysCalRecord | |
| asdm::SysCalRow | Row of a SysCalTable |
| asdm::SysCalTable | Alma table |
| casa::sdfiller::SysCalTableRecord | |
| asdm::SysPowerRow | Row of a SysPowerTable |
| asdm::SysPowerTable | Alma table |
| casacore::SystemCallError | Exception for an error in a system call |
| casa::QtDataManager::tab_state | |
| casacore::Table | Main interface class to a read/write table |
| casacore::TableArrayConformanceError | Table error; non-conformant array |
| casacore::TableAttr | Some attributes of a table |
| casacore::TableCache | Cache of open tables |
| casacore::TableColumn | Read/write access to a table column |
| casacore::TableConformanceError | Table error; table length conformance error |
| casacore::TableCopy | Class with static functions for copying a table |
| casacore::TableDesc | Define the structure of a Casacore table |
| casacore::TableDescNoName | Table error; no name given to table description |
| casacore::TableDuplFile | Table error; table (description) already exists |
| casacore::TableError | Base error class for storage manager |
| casacore::TableExprAggrNode | TaQL node representing a scalar aggregate function |
| casacore::TableExprAggrNodeArray | TaQL node representing an array aggregate function |
| casacore::TableExprConeNode | Class representing a cone search in table select expression |
| casacore::TableExprConeNodeArray | |
| casacore::TableExprData | Abstract base class for data object in a TaQL expression |
| casacore::TableExprFuncNode | Class representing a function in table select expression |
| casacore::TableExprFuncNodeArray | Class representing an array function in table select expression |
| casacore::TableExprGroupAggr | Class collecting the arrays in a group |
| casacore::TableExprGroupAll | Aggregate class counting if all values in a group are true |
| casacore::TableExprGroupAny | Aggregate class counting if any value in a group is true |
| casacore::TableExprGroupArrayAll | Aggregate class counting if all array values in a group are true |
| casacore::TableExprGroupArrayAlls | Aggregate class counting per array index in a group if all are true |
| casacore::TableExprGroupArrayAny | Aggregate class counting if any array value in a group is true |
| casacore::TableExprGroupArrayAnys | Aggregate class counting per array index in a group if any is true |
| casacore::TableExprGroupArrayNFalse | Aggregate class counting the number of false array values in a group |
| casacore::TableExprGroupArrayNFalses | Aggregate class counting per array index in a group the nr of false values |
| casacore::TableExprGroupArrayNTrue | Aggregate class counting the number of true array values in a group |
| casacore::TableExprGroupArrayNTrues | Aggregate class counting per array index in a group the nr of true values |
| casacore::TableExprGroupCount | Aggregate class counting number of rows in a group containing a value |
| casacore::TableExprGroupCountAll | Aggregate class counting number of rows in a group |
| casacore::TableExprGroupExprId | Class derived from TableExprGroupFuncBase collecting the ids in a group |
| casacore::TableExprGroupFirst | Class derived from TableExprGroupFuncBase for the first value in a group |
| casacore::TableExprGroupFractileArrayDouble | Aggregate class determining the fractile of array values in a group |
| casacore::TableExprGroupFractileDouble | Aggregate class determining the fractile of values in a group |
| casacore::TableExprGroupFuncArrayBool | Abstract base class for aggregate functions giving a bool array |
| casacore::TableExprGroupFuncArrayDate | Abstract base class for aggregate functions giving a date/time array |
| casacore::TableExprGroupFuncArrayDComplex | Abstract base class for aggregate functions giving a dcomplex array |
| casacore::TableExprGroupFuncArrayDouble | Abstract base class for aggregate functions giving a double array |
| casacore::TableExprGroupFuncArrayInt | Abstract base class for aggregate functions giving an integer array |
| casacore::TableExprGroupFuncArrayString | Abstract base class for aggregate functions giving a string array |
| casacore::TableExprGroupFuncBase | Abstract base class for classes calculating an aggregated group result |
| casacore::TableExprGroupFuncBool | Abstract base class for aggregate functions giving a bool scalar |
| casacore::TableExprGroupFuncDate | Abstract base class for aggregate functions giving a date/time scalar |
| casacore::TableExprGroupFuncDComplex | Abstract base class for aggregate functions giving a dcomplex scalar |
| casacore::TableExprGroupFuncDouble | Abstract base class for aggregate functions giving a double scalar |
| casacore::TableExprGroupFuncInt | Abstract base class for aggregate functions giving an integer scalar |
| casacore::TableExprGroupFuncSet | Class containing the results of aggregated values in a group |
| casacore::TableExprGroupFuncString | Abstract base class for aggregate functions giving a string scalar |
| casacore::TableExprGroupHistBase | Base aggregate class determining the histogram of values in a group |
| casacore::TableExprGroupHistDouble | Aggregate class determining the histogram of double array values in a group |
| casacore::TableExprGroupHistInt | Aggregate class determining the histogram of integer array values in a group |
| casacore::TableExprGroupHistScalar | Aggregate class determining the histogram of scalar values in a group |
| casacore::TableExprGroupKey | Class representing a key in the groupby clause |
| casacore::TableExprGroupKeySet | Class representing all keys in the groupby clause |
| casacore::TableExprGroupLast | Class derived from TableExprGroupFuncBase for the first value in a group |
| casacore::TableExprGroupMaxArrayDouble | Aggregate class determining the maximum double array value in a group |
| casacore::TableExprGroupMaxArrayInt | Aggregate class determining the maximum integer array value in a group |
| casacore::TableExprGroupMaxDouble | Aggregate class determining the maximum double value in a group |
| casacore::TableExprGroupMaxInt | Aggregate class determining the maximum integer value in a group |
| casacore::TableExprGroupMaxsArrayDouble | Aggregate class determining the maximum double array value in a group |
| casacore::TableExprGroupMaxsArrayInt | Aggregate class determining per array index in a group the maximum value |
| casacore::TableExprGroupMeanArrayDComplex | Aggregate class determining the mean of complex array values in a group |
| casacore::TableExprGroupMeanArrayDouble | Aggregate class determining the mean of array values in a group |
| casacore::TableExprGroupMeanDComplex | Aggregate class determining the mean of complex values in a group |
| casacore::TableExprGroupMeanDouble | Aggregate class determining the mean of values in a group |
| casacore::TableExprGroupMeansArrayDComplex | Aggregate class determining the mean of complex array values in a group |
| casacore::TableExprGroupMeansArrayDouble | Aggregate class determining the mean of array values in a group |
| casacore::TableExprGroupMinArrayDouble | Aggregate class determining the minimum double array value in a group |
| casacore::TableExprGroupMinArrayInt | Aggregate class determining the minimum integer array value in a group |
| casacore::TableExprGroupMinDouble | Aggregate class determining the minimum double value in a group |
| casacore::TableExprGroupMinInt | Aggregate class determining the minimum integer value in a group |
| casacore::TableExprGroupMinsArrayDouble | Aggregate class determining the minimum double array value in a group |
| casacore::TableExprGroupMinsArrayInt | Aggregate class determining per array index in a group the minimum value |
| casacore::TableExprGroupNFalse | Aggregate class counting the number of false values in a group |
| casacore::TableExprGroupNTrue | Aggregate class counting the number of true values in a group |
| casacore::TableExprGroupNull | Class derived from TableExprGroupFuncBase representing a no function |
| casacore::TableExprGroupProductArrayDComplex | Aggregate class determining the product of complex array values in a group |
| casacore::TableExprGroupProductArrayDouble | Aggregate class determining the product of double array values in a group |
| casacore::TableExprGroupProductArrayInt | Aggregate class determining the product of integer array values in a group |
| casacore::TableExprGroupProductDComplex | Aggregate class determining the product of complex values in a group |
| casacore::TableExprGroupProductDouble | Aggregate class determining the product of double values in a group |
| casacore::TableExprGroupProductInt | Aggregate class determining the product of integer values in a group |
| casacore::TableExprGroupProductsArrayDComplex | Aggregate class determining the product of complex array values in a group |
| casacore::TableExprGroupProductsArrayDouble | Aggregate class determining the product of double array values in a group |
| casacore::TableExprGroupProductsArrayInt | Aggregate class determining per array index in a group the product of values |
| casacore::TableExprGroupResult | Class holding the results of groupby and aggregation |
| casacore::TableExprGroupRmsArrayDouble | Aggregate class determining the RMS of array values in a group |
| casacore::TableExprGroupRmsDouble | Aggregate class determining the RMS of values in a group |
| casacore::TableExprGroupRmssArrayDouble | Aggregate class determining the RMS of array values in a group |
| casacore::TableExprGroupRowid | Class collecting the rowids of entries in a group |
| casacore::TableExprGroupStdDevArrayDouble | Aggregate class determining the standard devation of array values in a group |
| casacore::TableExprGroupStdDevDouble | Aggregate class determining the standard deviation of values in a group |
| casacore::TableExprGroupStdDevsArrayDouble | Aggregate class determining the standard devation of array values in a group |
| casacore::TableExprGroupSumArrayDComplex | Aggregate class determining the sum of complex array values in a group |
| casacore::TableExprGroupSumArrayDouble | Aggregate class determining the sum of double array values in a group |
| casacore::TableExprGroupSumArrayInt | Aggregate class determining the sum of integer array values in a group |
| casacore::TableExprGroupSumDComplex | Aggregate class determining the sum of complex values in a group |
| casacore::TableExprGroupSumDouble | Aggregate class determining the sum of double values in a group |
| casacore::TableExprGroupSumInt | Aggregate class determining the sum of integer values in a group |
| casacore::TableExprGroupSumsArrayDComplex | Aggregate class determining the sum of complex array values in a group |
| casacore::TableExprGroupSumsArrayDouble | Aggregate class determining the sum of double array values in a group |
| casacore::TableExprGroupSumsArrayInt | Aggregate class determining per array index in a group the sum of values |
| casacore::TableExprGroupSumSqrArrayDComplex | Aggregate class determining the sum of squares of complex array values in a group |
| casacore::TableExprGroupSumSqrArrayDouble | Aggregate class determining the sum of squares of double array values in a group |
| casacore::TableExprGroupSumSqrArrayInt | Aggregate class determining the sum of squares of integer array values in a group |
| casacore::TableExprGroupSumSqrDComplex | Aggregate class determining the sum of squares of complex values in a group |
| casacore::TableExprGroupSumSqrDouble | Aggregate class determining the sum of squares of double values in a group |
| casacore::TableExprGroupSumSqrInt | Aggregate class determining the sum of squares of integer values in a group |
| casacore::TableExprGroupSumSqrsArrayDComplex | Aggregate class determining the sum of squares of complex array values in a group |
| casacore::TableExprGroupSumSqrsArrayDouble | Aggregate class determining the sum of squares of double array values in a group |
| casacore::TableExprGroupSumSqrsArrayInt | Aggregate class determining per array index in a group the sum of value squares in a group |
| casacore::TableExprGroupVarianceArrayDouble | Aggregate class determining the variance of array values in a group |
| casacore::TableExprGroupVarianceDouble | Aggregate class determining the variance of values in a group |
| casacore::TableExprGroupVariancesArrayDouble | Aggregate class determining the variance of array values in a group |
| casacore::TableExprId | The identification of a TaQL selection subject |
| casacore::TableExprIdAggr | The Table Expression Selection id used with aggregation |
| casacore::TableExprNode | Handle class for a table column expression tree |
| casacore::TableExprNodeAND | Logical and in table select expression tree |
| casacore::TableExprNodeArray | Base class for arrays in table select expression |
| casacore::TableExprNodeArrayAND | Logical and in table select expression tree |
| casacore::TableExprNodeArrayBitAndInt | Int Array bitwise and in table select expression tree |
| casacore::TableExprNodeArrayBitNegate | Bitwise negate in table select expression tree |
| casacore::TableExprNodeArrayBitOrInt | Int Array bitwise or in table select expression tree |
| casacore::TableExprNodeArrayBitXorInt | Int Array bitwise xor in table select expression tree |
| casacore::TableExprNodeArrayColumn | Base class for Array column in table select expression |
| casacore::TableExprNodeArrayColumnBool | Bool array column in table select expression |
| casacore::TableExprNodeArrayColumnComplex | Complex array column in table select expression |
| casacore::TableExprNodeArrayColumnDComplex | DComplex array column in table select expression |
| casacore::TableExprNodeArrayColumnDouble | Double array column in table select expression |
| casacore::TableExprNodeArrayColumnFloat | Float array column in table select expression |
| casacore::TableExprNodeArrayColumnInt | Int array column in table select expression |
| casacore::TableExprNodeArrayColumnShort | Short array column in table select expression |
| casacore::TableExprNodeArrayColumnString | String array column in table select expression |
| casacore::TableExprNodeArrayColumnuChar | UChar array column in table select expression |
| casacore::TableExprNodeArrayColumnuInt | UInt array column in table select expression |
| casacore::TableExprNodeArrayColumnuShort | UShort array column in table select expression |
| casacore::TableExprNodeArrayConstBool | Bool Array constant in table select expression tree |
| casacore::TableExprNodeArrayConstDate | Date Array constant in table select expression tree |
| casacore::TableExprNodeArrayConstDComplex | DComplex Array constant in table select expression tree |
| casacore::TableExprNodeArrayConstDouble | Double Array constant in table select expression tree |
| casacore::TableExprNodeArrayConstInt | Int Array constant in table select expression tree |
| casacore::TableExprNodeArrayConstString | String Array constant in table select expression tree |
| casacore::TableExprNodeArrayDivide | Array addition in table select expression tree |
| casacore::TableExprNodeArrayDivideDComplex | DComplex Array division in table select expression tree |
| casacore::TableExprNodeArrayDivideDouble | Double Array division in table select expression tree |
| casacore::TableExprNodeArrayEQBool | Bool Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQDate | Date Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQDComplex | DComplex Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQDouble | Double Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQInt | Int Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQRegex | Regex Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayEQString | String Array comparison == in table select expression tree |
| casacore::TableExprNodeArrayGEDate | Date Array comparison >= in table select expression tree |
| casacore::TableExprNodeArrayGEDComplex | DComplex Array comparison >= in table select expression tree |
| casacore::TableExprNodeArrayGEDouble | Double Array comparison >= in table select expression tree |
| casacore::TableExprNodeArrayGEInt | Int Array comparison >= in table select expression tree |
| casacore::TableExprNodeArrayGEString | String Array comparison >= in table select expression tree |
| casacore::TableExprNodeArrayGTDate | Date Array comparison > in table select expression tree |
| casacore::TableExprNodeArrayGTDComplex | DComplex Array comparison > in table select expression tree |
| casacore::TableExprNodeArrayGTDouble | Double Array comparison > in table select expression tree |
| casacore::TableExprNodeArrayGTInt | Int Array comparison > in table select expression tree |
| casacore::TableExprNodeArrayGTString | String Array comparison > in table select expression tree |
| casacore::TableExprNodeArrayINDate | Date Array comparison IN in table select expression tree |
| casacore::TableExprNodeArrayINDComplex | DComplex Array comparison IN in table select expression tree |
| casacore::TableExprNodeArrayINDouble | Double Array comparison IN in table select expression tree |
| casacore::TableExprNodeArrayINInt | Int Array comparison IN in table select expression tree |
| casacore::TableExprNodeArrayINString | String Array comparison IN in table select expression tree |
| casacore::TableExprNodeArrayMIN | Unary minus in table select expression tree |
| casacore::TableExprNodeArrayMinus | Array addition in table select expression tree |
| casacore::TableExprNodeArrayMinusDate | Date Array subtraction in table select expression tree |
| casacore::TableExprNodeArrayMinusDComplex | DComplex Array subtraction in table select expression tree |
| casacore::TableExprNodeArrayMinusDouble | Double Array subtraction in table select expression tree |
| casacore::TableExprNodeArrayMinusInt | Int Array subtraction in table select expression tree |
| casacore::TableExprNodeArrayModulo | Array addition in table select expression tree |
| casacore::TableExprNodeArrayModuloDouble | Double Array modulo in table select expression tree |
| casacore::TableExprNodeArrayModuloInt | Int Array modulo in table select expression tree |
| casacore::TableExprNodeArrayNEBool | Bool Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNEDate | Date Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNEDComplex | DComplex Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNEDouble | Double Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNEInt | Int Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNERegex | Regex Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNEString | String Array comparison != in table select expression tree |
| casacore::TableExprNodeArrayNOT | Logical not in table select expression tree |
| casacore::TableExprNodeArrayOR | Logical or in table select expression tree |
| casacore::TableExprNodeArrayPart | Array column part in table select expression |
| casacore::TableExprNodeArrayPlus | Array addition in table select expression tree |
| casacore::TableExprNodeArrayPlusDate | Date Array addition in table select expression tree |
| casacore::TableExprNodeArrayPlusDComplex | DComplex Array addition in table select expression tree |
| casacore::TableExprNodeArrayPlusDouble | Double Array addition in table select expression tree |
| casacore::TableExprNodeArrayPlusInt | Int Array addition in table select expression tree |
| casacore::TableExprNodeArrayPlusString | String Array addition in table select expression tree |
| casacore::TableExprNodeArrayTimes | Array addition in table select expression tree |
| casacore::TableExprNodeArrayTimesDComplex | DComplex Array multiplication in table select expression tree |
| casacore::TableExprNodeArrayTimesDouble | Double Array multiplication in table select expression tree |
| casacore::TableExprNodeArrayTimesInt | Int Array multiplication in table select expression tree |
| casacore::TableExprNodeArrayUnit | Unit for array values in a table select expression tree |
| casacore::TableExprNodeBinary | Abstract base class for a node having 0, 1, or 2 child nodes |
| casacore::TableExprNodeBitAndInt | Bitwise and in table select expression tree |
| casacore::TableExprNodeBitNegate | Bitwise negate in table select expression tree |
| casacore::TableExprNodeBitOrInt | Bitwise or in table select expression tree |
| casacore::TableExprNodeBitXorInt | Bitwise xor in table select expression tree |
| casacore::TableExprNodeColumn | Scalar column in table select expression tree |
| casacore::TableExprNodeConstBool | Constant Bool in table select expression tree |
| casacore::TableExprNodeConstDate | Constant Date in table select expression tree |
| casacore::TableExprNodeConstDComplex | Constant DComplex in table select expression tree |
| casacore::TableExprNodeConstDouble | Constant Double in table select expression tree |
| casacore::TableExprNodeConstInt | Constant Int64 in table select expression tree |
| casacore::TableExprNodeConstRegex | Constant Regex or StringDistance in table select expression tree |
| casacore::TableExprNodeConstString | Constant String in table select expression tree |
| casacore::TableExprNodeDivide | Division in table select expression tree |
| casacore::TableExprNodeDivideDComplex | DComplex division in table select expression tree |
| casacore::TableExprNodeDivideDouble | Double division in table select expression tree |
| casacore::TableExprNodeEQBool | Bool comparison == in table select expression tree |
| casacore::TableExprNodeEQDate | Date comparison == in table select expression tree |
| casacore::TableExprNodeEQDComplex | DComplex comparison == in table select expression tree |
| casacore::TableExprNodeEQDouble | Double comparison == in table select expression tree |
| casacore::TableExprNodeEQInt | Int comparison == in table select expression tree |
| casacore::TableExprNodeEQRegex | Regex comparison == in table select expression tree |
| casacore::TableExprNodeEQString | String comparison == in table select expression tree |
| casacore::TableExprNodeGEDate | Date comparison >= in table select expression tree |
| casacore::TableExprNodeGEDComplex | DComplex comparison >= in table select expression tree |
| casacore::TableExprNodeGEDouble | Double comparison >= in table select expression tree |
| casacore::TableExprNodeGEInt | Int comparison >= in table select expression tree |
| casacore::TableExprNodeGEString | String comparison >= in table select expression tree |
| casacore::TableExprNodeGTDate | Date comparison > in table select expression tree |
| casacore::TableExprNodeGTDComplex | DComplex comparison > in table select expression tree |
| casacore::TableExprNodeGTDouble | Double comparison > in table select expression tree |
| casacore::TableExprNodeGTInt | Int comparison > in table select expression tree |
| casacore::TableExprNodeGTString | String comparison > in table select expression tree |
| casacore::TableExprNodeINDate | Date comparison IN in table select expression tree |
| casacore::TableExprNodeINDComplex | DComplex comparison IN in table select expression tree |
| casacore::TableExprNodeIndex | The index of an array element in a table select expression |
| casacore::TableExprNodeINDouble | Double comparison IN in table select expression tree |
| casacore::TableExprNodeINInt | Int comparison IN in table select expression tree |
| casacore::TableExprNodeINString | String comparison IN in table select expression tree |
| casacore::TableExprNodeMIN | Unary minus in table select expression tree |
| casacore::TableExprNodeMinus | Subtraction in table select expression tree |
| casacore::TableExprNodeMinusDate | Date subtraction in table select expression tree |
| casacore::TableExprNodeMinusDComplex | DComplex subtraction in table select expression tree |
| casacore::TableExprNodeMinusDouble | Double subtraction in table select expression tree |
| casacore::TableExprNodeMinusInt | Int subtraction in table select expression tree |
| casacore::TableExprNodeModulo | Modulo in table select expression tree |
| casacore::TableExprNodeModuloDouble | Double modulo in table select expression tree |
| casacore::TableExprNodeModuloInt | Int modulo in table select expression tree |
| casacore::TableExprNodeMulti | Abstract base class for a node having multiple child nodes |
| casacore::TableExprNodeNEBool | Bool comparison != in table select expression tree |
| casacore::TableExprNodeNEDate | Date comparison != in table select expression tree |
| casacore::TableExprNodeNEDComplex | DComplex comparison != in table select expression tree |
| casacore::TableExprNodeNEDouble | Double comparison != in table select expression tree |
| casacore::TableExprNodeNEInt | Int comparison != in table select expression tree |
| casacore::TableExprNodeNERegex | Regex comparison != in table select expression tree |
| casacore::TableExprNodeNEString | String comparison != in table select expression tree |
| casacore::TableExprNodeNOT | Logical not in table select expression tree |
| casacore::TableExprNodeOR | Logical or in table select expression tree |
| casacore::TableExprNodePlus | Addition in table select expression tree |
| casacore::TableExprNodePlusDate | Date addition in table select expression tree |
| casacore::TableExprNodePlusDComplex | DComplex addition in table select expression tree |
| casacore::TableExprNodePlusDouble | Double addition in table select expression tree |
| casacore::TableExprNodePlusInt | Int addition in table select expression tree |
| casacore::TableExprNodePlusString | String addition in table select expression tree |
| casacore::TableExprNodeRandom | Random number in table select expression tree |
| casacore::TableExprNodeRecordField | Scalar field in record select expression tree |
| casacore::TableExprNodeRecordFieldArray | Array field in record select expression tree |
| casacore::TableExprNodeRep | Abstract base class for a node in a table column expression tree |
| casacore::TableExprNodeRowid | Rowid in table select expression tree |
| casacore::TableExprNodeRownr | Rownumber in table select expression tree |
| casacore::TableExprNodeSet | Class to hold multiple table expression nodes |
| casacore::TableExprNodeSetElem | Class to hold the table expression nodes for an element in a set |
| casacore::TableExprNodeTimes | Multiplication in table select expression tree |
| casacore::TableExprNodeTimesDComplex | DComplex multiplication in table select expression tree |
| casacore::TableExprNodeTimesDouble | Double multiplication in table select expression tree |
| casacore::TableExprNodeTimesInt | Int multiplication in table select expression tree |
| casacore::TableExprNodeUnit | Unit for scalar values in a table select expression tree |
| casacore::TableExprRange | Select range of a column in an select expression |
| casacore::TableExprUDFNode | Class representing a scalar UDF in select expression |
| casacore::TableExprUDFNodeArray | Class representing an array UDF in select expression |
| casacore::TableGram_global_functions_TableGramFunctions | Global functions for flex/bison scanner/parser for TableGram |
| casacore::TableGramError | Table grammar error; invalid table command |
| casacore::TableIndexProxy | Proxy for table index access |
| casacore::TableInfo | Table type, subtype and further info |
| casacore::TableInternalError | Internal table error |
| casacore::TableInvColumnDesc | Table error; invalid column description |
| casacore::TableInvDT | Table error; invalid data type |
| casacore::TableInvExpr | Table error; invalid select expression |
| casacore::TableInvHyperDesc | Table error; invalid hypercolumn description |
| casacore::TableInvLogic | Table error; invalid logical operation |
| casacore::TableInvOper | Table error; invalid operation |
| casacore::TableInvOpt | Table error; invalid table (description) option |
| casacore::TableInvSort | Table error; invalid sort |
| casacore::TableInvType | Table error; table type mismatch |
| casacore::TableIterator | Iterate through a Table |
| casacore::TableIterProxy | Proxy for table iterator access |
| casacore::TableKeyword | Keyword value representing a table |
| casacore::TableLock | Class to hold table lock options |
| casacore::TableLockData | Class to hold table lock data |
| casacore::TableLocker | Class to hold a (user) lock on a table |
| casacore::TableLogSink | Save log messages in a Casacore Table |
| casacore::TableMeasColumn | Read only access to table scalar Measure columns |
| casacore::TableMeasDesc< M > | Definition of a Measure column in a Table |
| casacore::TableMeasDescBase | Definition of a Measure in a Table |
| casacore::TableMeasOffsetDesc | Definition of a Measure Offset in a Table |
| casacore::TableMeasRefDesc | Definition of a Measure Reference in a Table |
| casacore::TableMeasType | Definition of a Measure column in a Table |
| casacore::TableMeasValueDesc | Definition of a Measure Value in a Table |
| casacore::TableNoDatFile | Table error; table.dat file not found |
| casacore::TableNoDir | Table error; path is not a directory |
| casacore::TableNoFile | Table error; table (description) not found |
| casa::TableParams | Parameters that define all table data and meta-deta |
| casacore::TableParse | Class to hold values from table grammar parser |
| casacore::TableParseError | Table error; invalid table command |
| casacore::TableParseSelect | Select-class for flex/bison scanner/parser for TableParse |
| casacore::TableParseSort | Helper class for sort keys in TableParse |
| casacore::TableParseUpdate | Helper class for updates in TableParse |
| casacore::TableProxy | High-level interface to tables |
| casacore::TableQuantumDesc | A class for defining Quantum columns in Tables |
| casacore::TableRecord | A hierarchical collection of named fields of various types |
| casacore::TableRecordRep | The representation of a TableRecord |
| casacore::TableRow | Read/write access to a table row |
| casacore::TableRowProxy | Proxy for table row access |
| TableSAXReader< T, R, RFilter > | |
| asdm::TableStreamReader< T, R > | A generic class to read a file containing an ASDM table as a stream |
| casacore::TableSyncData | Class to hold table synchronization data |
| casacore::TableTrace | Class with static functions for tracing column IO |
| casacore::TableUnknownDesc | Table error; unknown column description |
| casacore::TableVector< T > | Templated readonly table column vectors |
| casacore::TableVectorNonConform | Table error; non-conformant table vectors |
| casacore::TabPath | Search path for table files |
| casacore::TabularCoordinate | Table lookup 1-D coordinate, with interpolation |
| casa::TabularSpectrum | Models the spectral variation with a spectral index |
| casa::refim::TabulatedConvFunc | |
| casa::TabulatedConvFunc | |
| casacore::TabVecLogic_global_functions_scalarComparison | Comparison between a table vector and a scalar |
| casacore::TabVecLogic_global_functions_vectorComparison | Comparison between two table vectors |
| casacore::TabVecMath_global_functions_advTransMath | Further transcendental math for table vectors |
| casacore::TabVecMath_global_functions_basicMath | Basic math for table vectors |
| casacore::TabVecMath_global_functions_basicTransMath | Transcendental math for table vectors |
| casacore::TabVecMath_global_functions_miscellaneous | Miscellaneous table vector operations |
| casacore::TabVecMath_global_functions_vectorMath | Vector operations on a table vector |
| casacore::TabVecRep< T > | Templated base class for table vectors |
| casacore::TabVecScaCol< T > | Templated table scalar column vectors |
| casacore::TabVecTemp< T > | Templated table vectors held in memory as a temporary |
| asdm::Tag | Implementation of a unique index identifying a row of an ASDM table |
| asdm::TagFormatException | The TagFormatException occurs when a Tag is built from a String which does not represent correctly the content of a Tag |
| asdm::TagType | A class to represent the type of Tag , i.e |
| asdm::TagType::TagTypeMgr | |
| casacore::Tan< T, RES > | Functor to apply tan |
| casacore::Tanh< T, RES > | Functor to apply tanh |
| TapeHeader | |
| casacore::TapeIO | Class for IO on a tape device |
| casacore::TaQLAddColNodeRep | Raw TaQL parse tree node defining an alter table add column command |
| casacore::TaQLAddRowNodeRep | Raw TaQL parse tree node defining an alter table add rows command |
| casacore::TaQLAltTabNodeRep | Raw TaQL parse tree node defining an alter table command |
| casacore::TaQLBinaryNodeRep | Raw TaQL parse tree node defining a binary operator |
| casacore::TaQLCalcNodeRep | Raw TaQL parse tree node defining a calc command |
| casacore::TaQLColNodeRep | Raw TaQL parse tree node defining a select column expression |
| casacore::TaQLColSpecNodeRep | Raw TaQL parse tree node defining a create column specification |
| casacore::TaQLColumnsNodeRep | Raw TaQL parse tree node defining a select column list |
| casacore::TaQLConcTabNodeRep | Raw TaQL parse tree node defining an alter table command |
| casacore::TaQLConstNode | Envelope class for a node containing a constant value |
| casacore::TaQLConstNodeRep | Raw TaQL parse tree node defining a constant value |
| casacore::TaQLCountNodeRep | Raw TaQL parse tree node defining a count command |
| casacore::TaQLCreTabNodeRep | Raw TaQL parse tree node defining a create table command |
| casacore::TaQLDeleteNodeRep | Raw TaQL parse tree node defining a delete command |
| casacore::TaQLFuncNodeRep | Raw TaQL parse tree node defining a function |
| casacore::TaQLGivingNodeRep | Raw TaQL parse tree node defining a giving expression list |
| casacore::TaQLGroupNodeRep | Raw TaQL parse tree node defining a groupby list |
| casacore::TaQLIndexNodeRep | Raw TaQL parse tree node defining an index in a array |
| casacore::TaQLInsertNodeRep | Raw TaQL parse tree node defining an insert command |
| casacore::TaQLJoinNodeRep | Raw TaQL parse tree node defining a join operation |
| casacore::TaQLKeyColNodeRep | Raw TaQL parse tree node defining a keyword or column name |
| casacore::TaQLLimitOffNodeRep | Raw TaQL parse tree node defining a limit/offset expression |
| casacore::TaQLMultiNode | Envelope class for a node containing a list of nodes |
| casacore::TaQLMultiNodeRep | Raw TaQL parse tree node defining a list of nodes |
| casacore::TaQLNode | Envelope class for a node in the raw TaQL parse tree |
| casacore::TaQLNodeHandler | Class to handle the nodes in the raw TaQL parse tree |
| casacore::TaQLNodeHRValue | Class containing the result value of the handling of a TaQLNode |
| casacore::TaQLNodeRep | Representation of a node in the raw TaQL parse tree |
| casacore::TaQLNodeResult | Envelope class to hold the result of a visit to the node tree |
| casacore::TaQLNodeResultRep | Abstract base class to hold the result of a visit to the node tree |
| casacore::TaQLNodeVisitor | Class to visit the nodes in the raw TaQL parse tree |
| casacore::TaQLQueryNode | Envelope class for a node containing a selection command |
| casacore::TaQLQueryNodeRep | Raw TaQL parse tree node defining a selection command |
| casacore::TaQLRangeNodeRep | Raw TaQL parse tree node defining a range |
| casacore::TaQLRecFldNodeRep | Raw TaQL parse tree node defining a record field |
| casacore::TaqlRegex | Class to handle a Regex or StringDistance |
| casacore::TaQLRegexNode | Envelope class for a node containing a constant regex value |
| casacore::TaQLRegexNodeRep | Raw TaQL parse tree node defining a constant regex value |
| casacore::TaQLRenDropNodeRep | Raw TaQL parse tree node defining an alter table rename or drop command |
| casacore::TaQLResult | Class to hold the result of a TaQL command |
| casacore::TaQLSelectNodeRep | Raw TaQL parse tree node defining a select command |
| casacore::TaQLSetKeyNodeRep | Raw TaQL parse tree node defining an alter table set keyword command |
| casacore::TaQLShow | Class to show various TaQL-related info |
| casacore::TaQLShowNodeRep | Raw TaQL parse tree node defining a show command |
| casacore::TaQLSortKeyNodeRep | Raw TaQL parse tree node defining a sort key |
| casacore::TaQLSortNodeRep | Raw TaQL parse tree node defining a sort list |
| casacore::TaQLStyle | Class with static members defining the TaQL style |
| casacore::TaQLTableNodeRep | Raw TaQL parse tree node defining a table |
| casacore::TaQLUnaryNodeRep | Raw TaQL parse tree node defining a unary operator |
| casacore::TaQLUnitNodeRep | Raw TaQL parse tree node defining a unit |
| casacore::TaQLUpdateNodeRep | Raw TaQL parse tree node defining an update command |
| casacore::TaQLUpdExprNodeRep | Raw TaQL parse tree node defining a column update expression |
| casa::TBAction | Abstract parent class of any action that can be performed |
| casa::TBActionList | Contains an list of performed actions and a list of undone actions |
| casa::TBArray | Holds a potentially multi-dimensional array |
| casa::TBArrayData | Data type that holds an array |
| casa::TBArrayDataBool | Implementation of TBArrayData for boolean array data |
| casa::TBArrayDataChar | Implementation of TBArrayData for character array data |
| casa::TBArrayDataComplex | Implementation of TBArrayData for complex array data |
| casa::TBArrayDataDComplex | Implementation of TBArrayData for double complex array data |
| casa::TBArrayDataDouble | Implementation of TBArrayData for double array data |
| casa::TBArrayDataFloat | Implementation of TBArrayData for float array data |
| casa::TBArrayDataInt | Implementation of TBArrayData for int array data |
| casa::TBArrayDataShort | Implementation of TBArrayData for short array data |
| casa::TBArrayDataString | Implementation of TBArrayData for String array data |
| casa::TBArrayDataUChar | Implementation of TBArrayData for unsigned character array data |
| casa::TBArrayDataUInt | Implementation of TBArrayData for unsigned int array data |
| casa::TBArrayPanel | Panel that can hold multiple TBViewArray widgets |
| casa::TBBrowser | Browser widget for managing opened tables |
| casa::TBConnection | Dialog for opening/connecting to a table with options |
| casa::TBConstants | Constants, defaults, and commonly-used functions for the table browser |
| casa::TBData | Data types used for loaded data |
| casa::TBDataBool | Implementation of TBData for boolean data |
| casa::TBDataChar | Implementation of TBData for character data |
| casa::TBDataComplex | Implementation of TBData for complex data |
| casa::TBDataDate | Implementation of TBData for date data |
| casa::TBDataDComplex | Implementation of TBData for double complex data |
| casa::TBDataDouble | Implementation of TBData for double data |
| casa::TBDataFloat | Implementation of TBData for float data |
| casa::TBDataInt | Implementation of TBData for integer data |
| casa::TBDataItem | Subclass of QTableWidgetItem that allows for custom sorting |
| casa::TBDataRecord | Implementation of TBData for Record data |
| casa::TBDataShort | Implementation of TBData for short data |
| casa::TBDataString | Implementation of TBData for String data |
| casa::TBDataTab | Widget used to display table data |
| casa::TBDataTable | Implementation of TBData for Table data |
| casa::TBDataUChar | Implementation of TBData for unsigned character data |
| casa::TBDataUInt | Implementation of TBData for unsigned int data |
| casa::TBEditArrayDataAction | TBAction for when array data in the table is edited |
| casa::TBEditDataAction | TBAction for when non-array data in the table is edited |
| casa::TBExportThread | Thread that exports a table to VOTable XML format |
| casa::TBField | Representation of a table field |
| casa::TBFieldKeywordsTab | Widget used to display field keywords |
| casa::TBFilterRule | Rule that can be used to filter rows based upon field values |
| casa::TBFilterRules | Widget to allow the user to enter a filter rule sequence |
| casa::TBFilterRuleSequence | A sequence of TBFilterRules that can be used to filter rows |
| casa::TBFormat | Rules used to format displayed values for fields |
| casa::TBFormatter | Widget for entering format rules for a given field |
| casa::TBHelp | Widget for displaying and updating the browser help files |
| casa::TBHomeParser | TBParser subclass that uses a "home" parsing method |
| casa::TBIDFieldsTest | Tests whether fields ending in _ID have a corresponding subtable |
| casa::TBKeyword | Representation of a keyword attached to a table or field |
| casa::TblAsContourDD | Class for displaying data within a table as a contour image |
| casa::TblAsContourDM | A DisplayMethod to draw Contours from table data |
| casa::TblAsRasterDD | Class for displaying data within a table as a raster image |
| casa::TblAsRasterDM | A DisplayMethod to draw Raster images from table data |
| casa::TblAsXYDD | Class for displaying data within a table as a xy image |
| casa::TblAsXYDM | A DisplayMethod to draw XY plots from table data |
| casa::TBLocatedRows | Results of a row locate on at least one table |
| casa::TBMain | Main window which is mainly responsible for menu actions |
| casa::TBNewKeyword | |
| casa::TBOptions | Widget to edit the browsing options |
| casa::TBParser | Parses the XMLDriver-generated XML into data in a TBTable |
| casa::TBPlotCanvas | Canvas for data plotting using a given plotting implementation |
| casa::TBPlotData | Data for plotting |
| casa::TBPlotFormat | Format for the curves on the plot canvas |
| casa::TBPlotter | Widget to collect plot parameters and plot on the canvas |
| casa::TBRowLocate | Displays results of a row locate |
| casa::TBSlicer | Widget to display and change the current array slice |
| casa::TBSorter | Widget to configure a multi-field sort ordering |
| casa::TBSubtablesTest | Tests whether subtables exist on disk |
| casa::TBTable | Primary interface for the rest of the browser to a table |
| casa::TBTableDriver | Driver for interacting with the table on disk |
| casa::TBTableDriverDirect | TBTableDriver implementation that directly accesses the table on disk |
| casa::TBTableDriverXML | NOTE: the TBTableDriverXML has been disabled |
| casa::TBTableInfo | Displays general information about a table |
| casa::TBTableKeywordsTab | Widget used to display table keywords |
| casa::TBTableTabs | Collection of table backend and display tabs |
| casa::TBTableView | Current "view" or state of a single table |
| casa::TBTaQL | GUI for entering a TaQL command |
| casa::TBTest | Tests to check the validity of a table |
| casa::TBTypes | (Not finished) Widget for entering a value based on its type |
| casa::TBValidityChecker | Widget for running TBTests on opened tables |
| casa::TBValidSubtablesTest | Tests whether subtables can be opened and have data |
| casa::TBView | Current "view" or state of the browser that can be serialized |
| casa::TBViewArray | Widget for viewing array data in TBArray format |
| casa::TBViewRecord | Widget for viewing record data |
| casa::TBXercesDOMParser | TBParser subclass that uses a DOM parser in the XERCES library |
| casa::TBXercesSAXParser | TBParser subclass that uses a SAX parser in the XERCES library |
| casa::PlotMSPlot::TCLParams | Simple class to hold parameter to resume updating after a threaded cache loading |
| asdm::Temperature | Implements a quantity of temperature in degrees Kelvin |
| casacore::TempImage< T > | Temporary astronomical images |
| casacore::Template | Canonicalise, format and other actions on Casacore template definitions |
| casacore::TempLattice< T > | A Lattice that can be used for temporary storage |
| casacore::TempLatticeImpl< T > | The class implementing TempLattice |
| casa::TextEditor | |
| casa::TfJones | ********************************************************** TfJones (freq-dep T) |
| casa::TfOpac | ********************************************************** TfOpac (freq-dep TOpac) |
| casa::async::Thread | |
| casa::ThreadCommunication | Defines communication mechanisms that the model and data can use to communicate with the UI concerning progress and status |
| casa::ThreadController | |
| casa::ThreadCoordinator< T > | |
| casa::ThreadCoordinatorBase | |
| casa::utilj::ThreadTimes | |
| casa::ThresholdingBinPlotDialog | This dialog displays a histogram that allows the user to set a minimum/maximum moment collapse threshold graphically |
| casacore::TiledCellStMan | Tiled Cell Storage Manager |
| casacore::TiledCollapser< T, U > | Abstract base class to collapse chunks for LatticeApply |
| casacore::TiledColumnStMan | Tiled Column Storage Manager |
| casacore::TiledDataStMan | Tiled Data Storage Manager |
| casacore::TiledDataStManAccessor | Give access to some TiledDataStMan functions |
| casacore::TiledFileAccess | Tiled access to an array in a file |
| casacore::TiledFileHelper | Helper class for tiled access to an array in a file |
| casacore::TiledLineStepper | Step a Vector cursor optimally through a tiled Lattice |
| casacore::TiledShape | Define the shape and tile shape |
| casacore::TiledShapeStMan | Tiled Data Storage Manager using the shape as id |
| casacore::TiledStMan | Base class for Tiled Storage Manager classes |
| casacore::TileStepper | Traverse a tiled Lattice optimally with a tile cursor |
| casacore::Time | Date and time enquiry functions, with some operations |
| casacore::TimeFields | |
| timeMgr | Class timeMgr is a utility to help for the management of time in tables with TIME and INTERVAL columns |
| casa::dbus::Timeout | |
| casacore::Timer | Measure the time it takes to execute parts of a program |
| casacore::MSMetaData::TimeStampProperties | |
| casacore::PrecTimer::TimeStruct | |
| casa::TimeVarMJonesDesc | TimeVarMJonesDesc: Define the format of TimeVarMJones cal tables |
| casa::TimeVarMJonesMRec | TimeVarMJonesMRec: TimeVarMJones cal_main table record access & creation |
| casa::TimeVarVisJonesDesc | TimeVarVisJonesDesc: Define the format of TimeVarVisJones cal tables |
| casa::TimeVarVisJonesMBuf | TimeVarVisJonesMBuf: TimeVarVisJones calibration main table buffer |
| casa::TimeVarVisJonesMCol | TimeVarVisJonesMCol: RW TimeVarVisJones cal_main column access |
| casa::TimeVarVisJonesMRec | TimeVarVisJonesMRec: TimeVarVisJones cal_main table record access & creation |
| casa::TimeVarVisJonesTable | TimeVarVisJonesTable: TimeVarVisJones calibration table access and creation |
| casa::vi::VlaData::Timing | |
| casa::asyncio::VlaData::Timing | |
| casa::TJones | ********************************************************** TJones |
| casa::TJonesDesc | TJonesDesc: Define the format of TJones cal tables |
| casa::TJonesMBuf | TJonesMBuf: TJones calibration main table buffer |
| casa::TJonesMCol | TJonesMCol: RW TJones cal_main column access |
| casa::TJonesMRec | TJonesMRec: TJones cal_main table record access & creation |
| casa::TJonesPolyDesc | TJonesPolyDesc: Define the format of TJonesPoly cal tables |
| casa::TJonesPolyMBuf | TJonesPolyMBuf: TJonesPoly calibration main table buffer |
| casa::TJonesPolyMCol | TJonesPolyMCol: RW TJonesPoly cal_main column access |
| casa::TJonesPolyTable | TJonesPolyTable: TJonesPoly calibration table access/creation |
| casa::TJonesSplineDesc | TJonesSplineDesc: Define the format of TJonesSpline cal tables |
| casa::TJonesSplineMBuf | TJonesSplineMBuf: TJonesSpline calibration main table buffer |
| casa::TJonesSplineMCol | TJonesSplineMCol: RW TJonesSpline cal_main column access |
| casa::TJonesSplineTable | TJonesSplineTable: TJonesSpline calibration table access/creation |
| casa::TJonesTable | TJonesTable: TJones calibration table access and creation |
| casa::ToLCRegionConversionError | Just need a identifable expection class, compiler can generate implementation implicitly |
| casa::ToolTipPicker | |
| casa::TOpac | ********************************************************** TOPac |
| asdm::TotalPowerRow | Row of a TotalPowerTable |
| asdm::TotalPowerTable | Alma table |
| asdmbinaries::TPSubsetHeaderParser | Class TPSubsetHeaderParser |
| casa::TrackBox | Helper class for QtDisplayPanelGui, for display of tracking information |
| casa::TrackerKeyHandler | Registered with all Canvases so Tracker can act upon key presses |
| casa::vi::TransformingVi2 | VisibilityIterator2 iterates through one or more readonly MeasurementSets |
| casacore::Trim | Functor to trim a std::string |
| casacore::TSMColumn | A column in the Tiled Storage Manager |
| casacore::TSMCoordColumn | A coordinate column in Tiled Storage Manager |
| casacore::TSMCube | Tiled hypercube in a table |
| casacore::TSMCubeBuff | Tiled hypercube in a table |
| casacore::TSMCubeMMap | Tiled hypercube in a table |
| casacore::TSMDataColumn | A data column in Tiled Storage Manager |
| casacore::TSMError | Table DataManager error; error in TiledStMan |
| casacore::TSMFile | File object for Tiled Storage Manager |
| casacore::TSMIdColumn | An id column in Tiled Storage Manager |
| casacore::TSMOption | Options for the Tiled Storage Manager Access |
| casacore::TSMShape | Expanded IPosition for shapes |
| casacore::TVec_global_functions_enum | Enumeration of possible table vectors |
| casacore::TVecLogic_global_functions_scalarComparison | Comparison between a table vector and a scalar |
| casacore::TVecLogic_global_functions_vectorComparison | Comparison between two table vectors |
| casacore::TVecMath_global_functions_advTransMath | Further transcendental math for table vectors |
| casacore::TVecMath_global_functions_basicMath | Basic math for table vectors |
| casacore::TVecMath_global_functions_basicTransMath | Transcendental math for table vectors |
| casacore::TVecMath_global_functions_miscellaneous | Miscellaneous table vector operations |
| casacore::TVecMath_global_functions_vectorMath | Vector operations on a table vector |
| casa::TwoPointCorrelator< T > | |
| casa::TwoSidedShape | Base class for component shapes with two sides |
| casacore::TypeIO | Abstract base class for IO of data in a type-dependent format |
| casacore::UDFBase | Abstract base class for a user-defined TaQL function |
| casacore::UDFMSCal | TaQL UDFs to calculate derived MS values |
| casacore::UDFMSCalErrorHandler | Error handler class for MSSel selection |
| casacore::uIntSequence | UInt sequence for general use |
| casacore::Unary< T > | Unary |
| casacore::UnaryFunction< T > | A one dimensional unary function |
| casa::utilj::UnaryFunctor< D, R > | |
| casacore::UnaryParam< T > | Parameter handling for one dimensional unary function |
| UnavailableMiriadDataSelectionError | Exception indicating that a requested data selection from a Miriad dataset is not available |
| casacore::UnequalShapeCopier< T > | Unequal shape copier |
| casacore::Uniform | Uniform distribution |
| casacore::PrecTimer::Union1 | |
| casacore::PrecTimer::Union2 | |
| casa::async::UniqueLock | |
| asdm::UniquenessViolationException | Exception occuring when one tries to add a row in table whose all mandatory attributes values except the autoincrementable one are already met in an existing row of the table |
| casacore::Unit | Defines physical units |
| casacore::UnitDim | Describes a unit in basic SI unit dimensions |
| casacore::UnitMap | All simple known physical units |
| casacore::UnitName | Handles physical units |
| casacore::UnitVal | Describes any valid unit as a factor and a dimenion of SI units |
| casacore::UnitVal_global_functions_output | Global output function |
| casacore::UnitVal_static_initializer | Static initialisation of UnitVal constants |
| casacore::UnrecognizedFunctionError | |
| casacore::Upcase | Functor to upcase a std::string |
| use | |
| asdm::UTCCorrection | |
| casa::Util | |
| asdmbinaries::Utils | SDMDataSubset:: declarations |
| casa::vi::UVContEstimationGSLKernel | |
| casa::vi::UVContEstimationKernel | |
| casa::vi::UVContSubKernel | |
| casa::vi::UVContSubtractionGSLKernel | |
| casa::vi::UVContSubtractionKernel | |
| casa::vi::UVContSubTransformEngine< T > | |
| casa::vi::UVContSubTVI | |
| casa::vi::UVContSubTVIFactory | |
| casa::vi::UVContSubTVILayerFactory | |
| casa::UVMod | VisCal: Model multiplicative errors for the VisEquation |
| UvwCoords | SDM UVW engine: compute the uvw these being not present in the SDM but required to build MS main table |
| casacore::UVWJ2000Column | UVW J2000 derived from TIME, etc |
| casacore::UVWMachine | Converts UVW coordinates between coordinate systems |
| casa::QtDataManager::validation_msg | |
| casacore::ValType | Data types and their undefined values |
| casacore::ValTypeId_global_functions_typeid | The id-string of a value type |
| casacore::ValueHolder | A holder for a value of any basic Casacore data type |
| casacore::ValueHolderRep | A holder for a value of any basic type |
| casacore::VanVleck | A class of static functions to aid with vanVleck corrections of lag data |
| casacore::VariableArrayFITSFieldCopier< recordType, fitsType > | |
| casacore::ArrayPartMath_global_functions_Array_partial_operations::VarianceFunc< T > | |
| casa::dbus::variant | |
| casacore::VAXConversion | A class with static functions to convert VAX format |
| casacore::VAXDataConversion | A class with virtual functions to convert VAX format |
| casa::vi::VbCacheItem< T, IsComputed > | |
| casa::vi::VbCacheItemArray< T, IsComputed > | |
| casa::vi::VbCacheItemBase | |
| casa::VBContinuumSubtractor | Fits and optionally subtracts the continuum in visibility spectra |
| casa::VbDirtyComponents | VbDirtyComponents allows marking portions of a VisBuffer as modified (aka dirty). This feature is needed for the Visibility Processing Framework (VPF) which allows a sequence of data processing nodes to work as a bucket brigade operating sequentially on a VisBuffer. A downstream output node needs to know what data, if any, needs to be written out |
| casa::VBGContinuumSubtractor | VBGContinuumSubtractors subtract the continuum out of VisBuffGroups |
| casa::ms::Vbi2MsRow | |
| casa::vpf::VbPtr | |
| casa::VBRemapper | VBRemappers remap VisBuffers |
| casa::refim::VBStore | |
| casa::VBStore | |
| casacore::Vector< T > | A 1-D Specialization of the Array class |
| casacore::VectorIterator< T > | Iterate an Vector cursor through another Array |
| casacore::VectorKernel | Make a Vector smoothing kernel from a kernel specification |
| casacore::VectorSTLIterator< T > | Casacore Vector iterator |
| casa::VectorView< T > | |
| casa::VisibilityIteratorReadImpl::Velocity | |
| casacore::VelocityMachine | Converts between velocities and frequencies |
| casa::Vi2ChunkDataProvider< DataIterator, MaskIterator, WeightsIterator > | Data provider template class backed by VisibilityIterator2 instances |
| casa::Vi2ChunkStatisticsIteratee< DataIterator, WeightsIterator, MaskIterator > | This class is used to encapsulate the action(s) taken on a sequence of StatisticsAlgorithm instances that are generated by the Vi2ChunkDataProvider::foreachChunk() method, which can be used to compute statistics for each MS chunk provided by a VisibilityIterator2 instance |
| casa::Vi2StatsDataIterator< Transformed, Data > | Vi2StatsDataIterator is designed to support an on-the-fly application of a transformation between the values in the source array and the values provided by the iterator |
| casa::Vi2StatsFlagsIterator< T > | Vi2StatsFlagsIterator has the form of a CRTP base class to promote efficiency in iterator operations |
| casa::Vi2StatsSigmasIterator< T > | Vi2StatsSigmasIterator has the form of a CRTP base class to promote efficiency in iterator operations |
| casa::Vi2StatsWeightsIterator< T > | Vi2StatsWeightsIterator has the form of a CRTP base class to promote efficiency in iterator operations |
| casa::vi::ViColumns2 | |
| casa::ViewerProxy | |
| casa::vi::ViFactory | |
| Viff | |
| casa::vi::ViiLayerFactory | |
| casa::vi::ViImplementation2 | VisibilityIterator2 iterates through one or more readonly MeasurementSets |
| casa::ViReadImplAsync | |
| casacore::VirtScaCol_global_functions_getVirtualScalarColumn | Global functions to get or put data of a virtual column |
| casacore::VirtualArrayColumn< T > | Templated base class for virtual array column |
| casacore::VirtualColumnEngine | Abstract base class for virtual column handling |
| casacore::VirtualScalarColumn< T > | Templated base class for virtual scalar column |
| casacore::VirtualTaQLColumn | Virtual scalar column using TaQL |
| casa::VisBuffAccumulator | A class to average VisBuffers in time |
| casa::VisBuffer | VisBuffers encapsulate one chunk of visibility data for processing |
| casa::vi::VisBuffer2 | VisBuffer2s encapsulate one chunk of visibility data for processing |
| casa::vi::VisBuffer2Adapter | |
| casa::VisBufferAsync | |
| casa::VisBufferAsyncWrapper | VisBuffers encapulsate one chunk of visibility data for processing |
| casa::VisBufferAutoPtr | A convenience class to assist in migrating code to potentially use asynchronous I/O |
| casa::vi::VisBufferCache | |
| casa::VisBufferComponents | This class encapsulates an enum with values corresponding to the various data components accessible via a VisBuffer. Its current usage is to specify the VisBuffer components to be prefetched when asynchronous I/O is in use or to specify the VisBuffer components that have been modified when a Visibility Processing Framework bucket-brigade is operating on a VisBuffer. This implementation should be replaced by a C++11 when the standard matures a bit |
| casa::vi::VisBufferComponents2 | This class encapsulates an enum with values corresponding to the various data components accessible via a VisBuffer. Its current usage is to specify the VisBuffer components to be prefetched when asynchronous I/O is in use or to specify the VisBuffer components that have been modified when a Visibility Processing Framework bucket-brigade is operating on a VisBuffer. This implementation should be replaced by a C++11 when the standard matures a bit |
| casa::vi::VisBufferImpl | VisBufferImpls encapsulate one chunk of visibility data for processing |
| casa::vi::VisBufferImpl2 | VisBufferImpls encapsulate one chunk of visibility data for processing |
| casa::vi::VisBufferImplAsync2 | |
| casa::vi::VisBufferState | |
| casa::VisBufferUtil | |
| casa::vi::VisBufferUtil2 | |
| casa::vi::VisBufferWrapperAsync2 | VisBuffers encapulsate one chunk of visibility data for processing |
| casa::VisBuffGroup | A class to store a group of VisBuffers |
| casa::VisBuffGroupAcc | A class to group separately averaged VisBuffers |
| casa::VisCal | ********************************************************** VisCal |
| casa::VisCalEnum | |
| casa::VisCalSolver | VisCalSolver: Default solver for calibration using visibility data |
| casa::VisCalSolver2 | VisCalSolver2: Default solver for calibration using visibility data |
| casa::VisChunkAverager | |
| casa::VisEquation | |
| casa::VisibilityIterator | VisibilityIterator iterates through one or more writable MeasurementSets |
| casa::vi::VisibilityIterator2 | VisibilityIterator2 iterates through one or more readonly MeasurementSets |
| casa::vi::VisibilityIteratorImpl2 | VisibilityIterator2 iterates through one or more readonly MeasurementSets |
| casa::vi::VisibilityIteratorImplAsync2 | VisibilityIterator2 iterates through one or more readonly MeasurementSets |
| casa::VisibilityIteratorReadImpl | ROVisibilityIterator iterates through one or more readonly MeasurementSets |
| casa::VisibilityIteratorWriteImpl | VisibilityIterator iterates through one or more writable MeasurementSets |
| casa::vpf::VisibilityProcessor | |
| casa::vpf::VisibilityProcessorStub | |
| casa::refim::VisibilityResampler | |
| casa::VisibilityResampler | |
| casa::refim::VisibilityResamplerBase | |
| casa::VisibilityResamplerBase | |
| casa::VisImagingWeight | Object to hold type of imaging weight scheme to be used on the fly and to provide facilities to do that |
| casa::VisIterator | |
| casa::VisJones | ********************************************************** VisJones |
| casa::VisJonesDesc | VisJonesDesc: Define the format of VisJones calibration tables |
| casa::VisJonesMBuf | VisJonesMBuf: VisJones calibration main table buffer |
| casa::VisJonesMCol | VisJonesMCol: Read-write VisJones cal_main calibration table column access |
| casa::VisJonesMRec | VisJonesMRec: VisJones cal_main table record access and creation |
| casa::VisJonesTable | VisJonesTable: VisJones calibration table access and creation |
| casa::VisMapper | |
| casa::VisModelData | Object to provide MODEL_DATA visibilities on demand |
| casa::refim::VisModelData | Object to provide MODEL_DATA visibilities on demand |
| casa::VisModelDataI | |
| casa::VisMueller | ********************************************************** VisMueller |
| casa::VisSet | |
| casa::VisSetUtil | Utilities for operating on VisSets |
| casa::VisVector | |
| casa::ViWriteImplAsync | |
| VLAADA | Interprets the data in an antenna data area of a VLA logical record |
| VLAArchiveInput | This class reads VLA archive records from a Tape |
| VLABaselineRecord | |
| casa::refim::VLACalcIlluminationConvFunc | Int getVLABandID(Double& freq,String&telescopeName); |
| casa::VLACalcIlluminationConvFunc | Int getVLABandID(Double& freq,String&telescopeName); |
| VLACalibratorFilter | |
| VLACDA | |
| VLAContinuumRecord | |
| casa::vi::VlaData | |
| casa::asyncio::VlaData | |
| casa::asyncio::VlaDatum | VlaDatum is a single elemement in the VlaDatum buffer ring used to support the ROVisibilityIteratorAsync |
| casa::vi::VlaDatum | VlaDatum is a single elemement in the VlaDatum buffer ring used to support the VisibilityIterator2Async |
| VLADiskInput | This class reads VLA archive records from a Disk file |
| VLAEnum | Enumerators common to the VLA module |
| VLAFiller | Functions to convert from VLA archive format to a MeasurementSet |
| VLAFilter | |
| VLAFilterSet | |
| VLAFrequencyFilter | |
| casa::refim::VLAIlluminationConvFunc | |
| casa::VLAIlluminationConvFunc | |
| VLALogicalRecord | This class interprets a VLA logical record |
| VLAObsModeFilter | |
| VLAOnlineInput | This class reads VLA archive records from the online computers |
| VLAProjectFilter | |
| VLARCA | |
| VLASDA | Interprets the data in an sub-array data area of a VLA logical record |
| VLASourceFilter | |
| VLASpectralLineRecord | |
| VLASubarrayFilter | |
| casa::asyncio::VLAT | VLAT is the Visibility LookAhead Thread. This thread advances a visibility iterator and fills the data indicated by the visibility iterator into the VlaData buffer ring |
| casa::vi::VLAT | VLAT is the Visibility LookAhead Thread. This thread advances a visibility iterator and fills the data indicated by the visibility iterator into the VlaData buffer ring |
| casa::vi::VlatAndData | |
| casa::asyncio::VlatAndData | |
| VLATapeInput | This class reads VLA archive records from a Tape |
| VLATapeIO | |
| casa::vi::VlatFunctor | VlatFunctor is an abstract class for functor objects used to encapsulate the various filling methods (e.g., fillVis, fillAnt1, etc |
| casa::asyncio::VlatFunctor | VlatFunctor is an abstract class for functor objects used to encapsulate the various filling methods (e.g., fillVis, fillAnt1, etc |
| casa::asyncio::VlatFunctor0< Ret, VbType > | |
| casa::vi::VlatFunctor0< Ret, VbType > | |
| casa::vi::VlatFunctor1< Ret, Arg > | |
| casa::asyncio::VlatFunctor1< Ret, Arg > | |
| VLATimeFilter | |
| sdmbin::VMSData | A structure containing the data from a single SDM BLOB |
| sdmbin::VMSDataWithSharedPtr | A structure containing the data from a single SDM BLOB |
| VOID | |
| casa::vpf::VpContainer | |
| casa::vpf::VpData | |
| casa::vpf::VpEngine | |
| casa::VPManager | |
| casa::vpf::VpPort | |
| casa::vpf::VpPorts | |
| casa::vpf::VpContainer::VpSet | |
| casa::VPSkyJones | Model the diagonal elements of the Voltage Pattern Sky Jones Matrices |
| casa::refim::VPSkyJones | Model the diagonal elements of the Voltage Pattern Sky Jones Matrices |
| casacore::VSCEngine< T > | Base virtual column for a scalar column with any type |
| casa::VWBT | |
| casa::dbus::Watch | |
| casa::WBCleanImageSkyModel | WB Clean Image Sky Model: Image Sky Model implementing a Wide-Band multi frequency synthesis algorithm |
| casa::WCAxisLabeller | Abstract class for drawing grids, axes, ticks and tick labels on a WorldCanvas |
| casacore::WCBox | Class to define a world coordinate box region of interest in an image |
| casacore::WCComplement | Make the complement of an image region |
| casacore::WCCompound | Base class for compound WCRegion objects |
| casacore::WCConcatenation | Combine multiple ImageRegion's into a new dimension |
| casa::WCCoordinateHandler | Base class defining a set of transformations for WorldCanvas coordinates |
| casa::WCCrosshairTool | Base class for WorldCanvas event-based crosshair tools |
| casa::WCCSAxisLabeller | Base class for WorldCanvas axis labelling using a DisplayCoordinateSystem |
| casa::WCCSNLAxisLabeller | Class which provides non-linear axis labelling using a DisplayCoordinateSystem |
| casa::WCDataScaleHandler | Class implementing simple data scaling for the WorldCanvas |
| casacore::WCDifference | Make the difference of 2 image regions |
| casacore::WCEllipsoid | Class to define an n-dimensional ellipsoid in world coordinates |
| casacore::WCExtension | Make the extension of an image region |
| casacore::WCIntersection | Make the intersection of 2 or more image regions |
| casa::WCInvisTool | Base implementation of WCTool for invisible (non-drawing) tools |
| casacore::WCLELMask | Class to define a mask as a LEL expression |
| casa::WCLinearScaleHandler | Linear scaling of data for WorldCanvases |
| casa::WCMotionEH | Base class for handling WorldCanvas motion events |
| casa::WCMotionEvent | Class which stores WorldCanvas motion event information |
| casa::WCPGFilter | Interface between the WorldCanvas and its PGPLOT driver |
| casacore::WCPolygon | Class to define a 2-D polygonal world coordinate region in an image |
| casa::WCPolyTool | Base class for WorldCanvas event-based polygon tools |
| casa::WCPositionEH | Base class for handling WorldCanvas position events |
| casa::WCPositionEvent | Class which stores WorldCanvas position event information |
| casa::WCPowerScaleHandler | Linear, logarithmic and exponential scaling of data for the WorldCanvas |
| casa::WCPTRegion | WorldCanvas event-based polygon region drawer |
| casa::WCRectTool | Base class for WorldCanvas event-based rectangle tools |
| casa::WCRefreshEH | Base class for handling WorldCanvas refresh events |
| casa::WCRefreshEvent | Class which stores WorldCanvas refresh event information |
| casacore::WCRegion | Base class to define world coordinate regions of interest in an image |
| casa::WCResampleHandler | Base class for resampling data pixels to World/PixelCanvas pixels |
| casa::WCRTRegion | WorldCanvas event-based rectangle region drawer |
| casa::WCRTZoomer | WorldCanvas event-based zoomer |
| casa::WCSimpleResampleHandler | Class which implements simple resampling for the WorldCanvas |
| casa::WCSizeControlHandler | Base class defining the interface to controlling the WorldCanvas size |
| casa::WCTool | Base class for WorldCanvas event-based tools |
| casa::WCToolMotEH | WorldCanvas motion event handler for WCTool |
| casa::WCToolPosEH | WorldCanvas position event handler for WCTool |
| casa::WCToolRefEH | WorldCanvas refresh event handler for WCTool |
| casacore::WCUnion | Make the union of 2 or more image regions |
| casa::sdfiller::WeatherRecord | |
| asdm::WeatherRow | Row of a WeatherTable |
| asdm::WeatherTable | Alma table |
| casa::WedgeDD | A DisplayData to draw color wedges |
| casa::WedgeDM | The DisplayMethod to draw Wedges |
| casacore::Weibull | Weibull distribution |
| casa::vi::WeightedChannelAverageKernel | |
| casa::vi::WeightScaling | |
| casa::vi::WeightScalingImpl< F > | |
| casa::WFCleanImageSkyModel | WF Image Sky Model: Image Sky Model implementing the WF Clean algorithm |
| casa::QtPlotSvrPanel::win_desc | |
| casa::window | MIRIAD dataset MeasurementSet filler |
| casa::Window3D | |
| casa::WOnlyConvFunc | ------------------------------------------------------------------------------------------- |
| casa::WOnlyProjectFT | |
| casa::WorldAxesDD | A DisplayData to setup a World coordinate plot |
| casa::WorldAxesDM | Class to draw a single set of axis labels for AxesDisplayData |
| casa::WorldCanvas | Implementation of drawing in world coordinates on top of a PixelCanvas |
| casa::WorldCanvasEvent | Base class describing event information for WorldCanvases |
| casa::WorldCanvasHolder | A holder to interface between DisplayDatas and a WorldCanvas |
| casa::WorldCanvasPGPlotDriver_global_functions_Driver_functions_called_by_FORTRAN_PgPlot_library | Global driver functions need to support PgPlot on the WorldCanvas |
| casa::WorldCanvasPGPlotDriver_global_functions_Global_functions_to_attach_to_existing_WorldCanvases | Global utility functions need to support PgPlot on the WorldCanvas |
| casa::WorldCanvasTranslator | |
| casa::WorldToPixelConversionError | Just need a identifiable exception class for exception handling |
| casa::refim::WPConvFunc | A class to support FTMachines get their convolution Function |
| casa::WPConvFunc | |
| casa::WProjectFT | An FTMachine for Gridded Fourier transforms |
| casa::refim::WProjectFT | An FTMachine for Gridded Fourier transforms |
| casacore::WrapperBase< T > | Aid in constructing function objects from C++ functions |
| casacore::WrapperData< T, U, V, hasX, hasParam > | Aid in constructing function objects from C++ functions |
| casacore::WrapperData_FF< T, T, T, False, False > | Specialization for calls with no arguments and no parameters |
| casacore::WrapperData_FT< T, T, T, False, True > | Specialization for calls with no arguments and parameter |
| casacore::WrapperData_FV< T, T, Vector< T >, False, True > | Specialization for calls with no arguments and parameters |
| casacore::WrapperData_TF< T, T, T, True, False > | Specialization for calls with argument and no parameters |
| casacore::WrapperData_TT< T, T, T, True, True > | Specialization for calls with argument and parameter |
| casacore::WrapperData_TV< T, T, Vector< T >, True, True > | Specialization for calls with argument and parameters |
| casacore::WrapperData_VF< T, Vector< T >, T, True, False > | Specialization for calls with argument and no parameters |
| casacore::WrapperData_VT< T, Vector< T >, T, True, True > | Specialization for calls with argument and parameter |
| casacore::WrapperData_VV< T, Vector< T >, Vector< T >, True, True > | Specialization for calls with argument and parameters |
| casacore::WrapperParam< T > | Parameter handling for wrapped function objects |
| casa::vi::WriteData | |
| casa::asyncio::WriteData | |
| casa::asyncio::WriteDataImpl< Data > | |
| casa::vi::WriteDataImpl< Data > | |
| casa::vi::WriteDataImpl2< Data > | |
| casa::asyncio::WriteDataImpl2< Data > | |
| casa::asyncio::WriteQueue | |
| casa::vi::WriteQueue | |
| casa::vpf::WriterVp | |
| casa::refim::WTerm | A class to apply the W-Term to the given image |
| casa::WTerm | A class to apply the W-Term to the given image |
| asdm::WVMCalRow | Row of a WVMCalTable |
| asdm::WVMCalTable | Alma table |
| casa::X11Intrinsic_global_functions_definitions | Make sure some definitions ok |
| casa::X11Util_global_functions_X11_Utility_Functions | X Utilities to assist the X11 classes |
| X_enter_global_functions_Definitions_for_Enter_X_Namespace | |
| X_exit_global_functions_Definitions_for_Exiting_X_Namespace | Include file to exit X name space |
| casa::XCorr | Model non-linear correlator function for the VisEquation |
| casa::XfJones | ********************************************************** Xf: position angle calibration (for circulars!) (channel-dependent) |
| casa::XJones | ********************************************************** X: position angle calibration (for circulars!) |
| enumerations::XMLConversionException | Exception when an error occurs in converting in restoring an Enumeration constant from its XML representation |
| casa::XMLFileReaderWriter | Implementation of RegionFileReader/RegionFileWriter for reading/writing CASA-XML files |
| casa::XMLtoken | Representation of a single XML token |
| casa::XMueller | ********************************************************** X: position angle calibration (for circulars!) (rendered as a Mueller for now) |
| asdm::XSLTransformer | A class to apply XSL transformations on an XML document |
| asdm::XSLTransformerException | A class to represent an exception thrown while an XSL transformation is applied by an instance of XSLTransformer |
| yyFlexLexer | |
| casa::utilj::Z | |
| asdmbinaries::SDMDataObject::ZeroLagsBinaryPart | A subclass of binaryPart to describe the zeroLags |
| casa::ZoomWidget | |
| casacore::ZScoreCalculator |
1.6.1
