diff --git a/LCS/MSLofar/include/MSLofar/CMakeLists.txt b/LCS/MSLofar/include/MSLofar/CMakeLists.txt
index 70fadb214da25fa3f5359db536ebfef13b31847d..497be378c53e42780929669e737cf03224b1f8cd 100644
--- a/LCS/MSLofar/include/MSLofar/CMakeLists.txt
+++ b/LCS/MSLofar/include/MSLofar/CMakeLists.txt
@@ -12,6 +12,10 @@ set (inst_HEADERS
MSAntennaFieldColumns.h
MSElementFailure.h
MSElementFailureColumns.h
+ MSLofarAntenna.h
+ MSLofarAntennaColumns.h
+ MSLofarObservation.h
+ MSLofarObsColumns.h
MSStation.h
MSStationColumns.h
BeamTables.h
diff --git a/LCS/MSLofar/include/MSLofar/MSLofarAntenna.h b/LCS/MSLofar/include/MSLofar/MSLofarAntenna.h
new file mode 100644
index 0000000000000000000000000000000000000000..fca81f065cdc394c786ca3ad1d72df4ab3e65e01
--- /dev/null
+++ b/LCS/MSLofar/include/MSLofar/MSLofarAntenna.h
@@ -0,0 +1,65 @@
+//# MSLofarAntenna.h: LOFAR MS ANTENNA_FIELD subtable
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#ifndef MSLOFAR_MSLOFARANTENNA_H
+#define MSLOFAR_MSLOFARANTENNA_H
+
+#include <ms/MeasurementSets/MSAntenna.h>
+#include <MSLofar/MSLofarTable.h>
+
+namespace LOFAR {
+
+ class MSLofarAntenna: public casa::MSAntenna
+ {
+ public:
+
+ // Default constructor creates an unusable object.
+ MSLofarAntenna();
+
+ // Create from an existing table.
+ MSLofarAntenna (const casa::String& tableName,
+ casa::Table::TableOption option);
+
+ // Create a new table.
+ MSLofarAntenna (casa::SetupNewTable& newTab, casa::uInt nrrow,
+ casa::Bool initialize);
+
+ // Create from an existing Table object.
+ MSLofarAntenna (const casa::Table& table);
+
+ // Copy constructor (reference semnatics).
+ MSLofarAntenna (const MSLofarAntenna& that);
+
+ // The destructor flushes the table if not done yet.
+ ~MSLofarAntenna();
+
+ // Assignment (reference semantics).
+ MSLofarAntenna& operator= (const MSLofarAntenna& that);
+
+ // Create the table description containing the required columns.
+ static casa::TableDesc requiredTableDesc();
+ };
+
+} //# end namespace
+
+#endif
diff --git a/LCS/MSLofar/include/MSLofar/MSLofarAntennaColumns.h b/LCS/MSLofar/include/MSLofar/MSLofarAntennaColumns.h
new file mode 100644
index 0000000000000000000000000000000000000000..41d00434c57c48742a05920ad028fe0f500a4b37
--- /dev/null
+++ b/LCS/MSLofar/include/MSLofar/MSLofarAntennaColumns.h
@@ -0,0 +1,153 @@
+//# MSLofarAntennaColumns.h: provides easy access to LOFAR's MSAntenna columns
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#ifndef MSLOFAR_MSLOFARANTENNACOLUMNS_H
+#define MSLOFAR_MSLOFARANTENNACOLUMNS_H
+
+#include <ms/MeasurementSets/MSAntennaColumns.h>
+
+namespace LOFAR {
+
+ //# Forward Declaration
+ class MSLofarAntenna;
+
+ // This class provides read-only access to the columns in the MSLofarAntenna
+ // Table. It does the declaration of all the Scalar and ArrayColumns with the
+ // correct types, so the application programmer doesn't have to worry about
+ // getting those right. There is an access function for every predefined
+ // column. Access to non-predefined columns will still have to be done with
+ // explicit declarations.
+
+ class ROMSLofarAntennaColumns: public casa::ROMSAntennaColumns
+ {
+ public:
+
+ // Create a columns object that accesses the data in the specified Table.
+ ROMSLofarAntennaColumns(const MSLofarAntenna& msLofarAntenna);
+
+ // The destructor does nothing special.
+ ~ROMSLofarAntennaColumns();
+
+ // Access to columns.
+ // <group>
+ const casa::ROScalarColumn<casa::Int>& stationId() const
+ { return stationId_p; }
+ const casa::ROArrayColumn<casa::Double>& phaseReference() const
+ { return phaseReference_p; }
+ const casa::ROArrayQuantColumn<casa::Double>& phaseReferenceQuant() const
+ { return phaseReferenceQuant_p; }
+ const casa::ROScalarMeasColumn<casa::MPosition>& phaseReferenceMeas() const
+ { return phaseReferenceMeas_p; }
+ // </group>
+
+ protected:
+ //# Default constructor creates a object that is not usable. Use the attach
+ //# function correct this.
+ ROMSLofarAntennaColumns();
+
+ //# Attach this object to the supplied table.
+ void attach (const MSLofarAntenna& msLofarAntenna);
+
+ private:
+ //# Make the assignment operator and the copy constructor private to prevent
+ //# any compiler generated one from being used.
+ ROMSLofarAntennaColumns(const ROMSLofarAntennaColumns&);
+ ROMSLofarAntennaColumns& operator=(const ROMSLofarAntennaColumns&);
+
+ //# required columns
+ casa::ROScalarColumn<casa::Int> stationId_p;
+ casa::ROArrayColumn<casa::Double> phaseReference_p;
+ //# Access to Measure columns
+ casa::ROScalarMeasColumn<casa::MPosition> phaseReferenceMeas_p;
+ //# Access to Quantum columns
+ casa::ROArrayQuantColumn<casa::Double> phaseReferenceQuant_p;
+ };
+
+
+ // This class provides read/write access to the columns in the MSLofarAntenna
+ // Table. It does the declaration of all the Scalar and ArrayColumns with the
+ // correct types, so the application programmer doesn't have to
+ // worry about getting those right. There is an access function
+ // for every predefined column. Access to non-predefined columns will still
+ // have to be done with explicit declarations.
+
+ class MSLofarAntennaColumns: public casa::MSAntennaColumns
+ {
+ public:
+
+ // Create a columns object that accesses the data in the specified Table.
+ MSLofarAntennaColumns(MSLofarAntenna& msLofarAntenna);
+
+ // The destructor does nothing special.
+ ~MSLofarAntennaColumns();
+
+ // Read-write access to required columns.
+ // <group>
+ const casa::ROScalarColumn<casa::Int>& stationId() const
+ { return roStationId_p; }
+ casa::ScalarColumn<casa::Int>& stationId()
+ { return rwStationId_p; }
+ const casa::ROArrayColumn<casa::Double>& phaseReference() const
+ { return roPhaseReference_p; }
+ casa::ArrayColumn<casa::Double>& phaseReference()
+ { return rwPhaseReference_p; }
+ const casa::ROArrayQuantColumn<casa::Double>& phaseReferenceQuant() const
+ { return roPhaseReferenceQuant_p; }
+ casa::ArrayQuantColumn<casa::Double>& phaseReferenceQuant()
+ { return rwPhaseReferenceQuant_p; }
+ casa::ROScalarMeasColumn<casa::MPosition>& phaseReferenceMeas()
+ { return roPhaseReferenceMeas_p; }
+ const casa::ScalarMeasColumn<casa::MPosition>& phaseReferenceMeas() const
+ { return rwPhaseReferenceMeas_p; }
+ // </group>
+
+ protected:
+ //# Default constructor creates a object that is not usable. Use the attach
+ //# function correct this.
+ MSLofarAntennaColumns();
+
+ //# Attach this object to the supplied table.
+ void attach(MSLofarAntenna& msLofarAntenna);
+
+ private:
+ //# Make the assignment operator and the copy constructor private to prevent
+ //# any compiler generated one from being used.
+ MSLofarAntennaColumns(const MSLofarAntennaColumns&);
+ MSLofarAntennaColumns& operator=(const MSLofarAntennaColumns&);
+
+ //# required columns
+ casa::ROScalarColumn<casa::Int> roStationId_p;
+ casa::ScalarColumn<casa::Int> rwStationId_p;
+ casa::ROArrayColumn<casa::Double> roPhaseReference_p;
+ casa::ArrayColumn<casa::Double> rwPhaseReference_p;
+ //# Access to Measure columns
+ casa::ROScalarMeasColumn<casa::MPosition> roPhaseReferenceMeas_p;
+ casa::ScalarMeasColumn<casa::MPosition> rwPhaseReferenceMeas_p;
+ //# Access to Quantum columns
+ casa::ROArrayQuantColumn<casa::Double> roPhaseReferenceQuant_p;
+ casa::ArrayQuantColumn<casa::Double> rwPhaseReferenceQuant_p;
+ };
+
+} //# end namespace
+
+#endif
diff --git a/LCS/MSLofar/include/MSLofar/MSLofarObsColumns.h b/LCS/MSLofar/include/MSLofar/MSLofarObsColumns.h
new file mode 100644
index 0000000000000000000000000000000000000000..253a10186bb3ba813cc7de4cd83f692975327fc9
--- /dev/null
+++ b/LCS/MSLofar/include/MSLofar/MSLofarObsColumns.h
@@ -0,0 +1,427 @@
+//# MSLofarObsColumns.h: provides easy access to LOFAR's MSObservation columns
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#ifndef MSLOFAR_MSLOFAROBSCOLUMNS_H
+#define MSLOFAR_MSLOFAROBSCOLUMNS_H
+
+#include <ms/MeasurementSets/MSObsColumns.h>
+
+namespace LOFAR {
+
+ //# Forward Declaration
+ class MSLofarObservation;
+
+ // This class provides read-only access to the columns in the MSLofarObservation
+ // Table. It does the declaration of all the Scalar and ArrayColumns with the
+ // correct types, so the application programmer doesn't have to worry about
+ // getting those right. There is an access function for every predefined
+ // column. Access to non-predefined columns will still have to be done with
+ // explicit declarations.
+
+ class ROMSLofarObservationColumns: public casa::ROMSObservationColumns
+ {
+ public:
+
+ // Create a columns object that accesses the data in the specified Table.
+ ROMSLofarObservationColumns(const MSLofarObservation& msLofarObservation);
+
+ // The destructor does nothing special.
+ ~ROMSLofarObservationColumns();
+
+ // Access to columns.
+ // <group>
+ const casa::ROScalarColumn<casa::String>& projectTitle() const
+ { return projectTitle_p; }
+ const casa::ROScalarColumn<casa::String>& projectPI() const
+ { return projectPI_p; }
+ const casa::ROArrayColumn<casa::String>& projectCoI() const
+ { return projectCoI_p; }
+ const casa::ROScalarColumn<casa::String>& projectContact() const
+ { return projectContact_p; }
+ const casa::ROScalarColumn<casa::String>& observationId() const
+ { return observationId_p; }
+ const casa::ROScalarColumn<casa::Double>& observationStart() const
+ { return observationStart_p; }
+ const casa::ROScalarColumn<casa::Double>& observationEnd() const
+ { return observationEnd_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyMax() const
+ { return observationFrequencyMax_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyMin() const
+ { return observationFrequencyMin_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyCenter() const
+ { return observationFrequencyCenter_p; }
+ const casa::ROScalarColumn<casa::Int>& subArrayPointing() const
+ { return subArrayPointing_p; }
+ const casa::ROScalarColumn<casa::String>& antennaSet() const
+ { return antennaSet_p; }
+ const casa::ROScalarColumn<casa::String>& filterSelection() const
+ { return filterSelection_p; }
+ const casa::ROScalarColumn<casa::Double>& clockFrequency() const
+ { return clockFrequency_p; }
+ const casa::ROArrayColumn<casa::String>& target() const
+ { return target_p; }
+ const casa::ROScalarColumn<casa::String>& systemVersion() const
+ { return systemVersion_p; }
+ const casa::ROScalarColumn<casa::String>& pipelineName() const
+ { return pipelineName_p; }
+ const casa::ROScalarColumn<casa::String>& pipelineVersion() const
+ { return pipelineVersion_p; }
+ const casa::ROScalarColumn<casa::String>& fileName() const
+ { return fileName_p; }
+ const casa::ROScalarColumn<casa::String>& fileType() const
+ { return fileType_p; }
+ const casa::ROScalarColumn<casa::Double>& fileDate() const
+ { return fileDate_p; }
+ // </group>
+
+ // Access to Quantity columns
+ // <group>
+ const casa::ROScalarQuantColumn<casa::Double>& observationStartQuant() const
+ { return observationStartQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationEndQuant() const
+ { return observationEndQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyMaxQuant() const
+ { return observationFrequencyMaxQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyMinQuant() const
+ { return observationFrequencyMinQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& clockFrequencyQuant() const
+ { return clockFrequencyQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyCenterQuant() const
+ { return observationFrequencyCenterQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& fileDateQuant() const
+ { return fileDateQuant_p; }
+ // </group>
+
+ // Access to Measure columns
+ // <group>
+ const casa::ROScalarMeasColumn<casa::MEpoch>& observationStartMeas() const
+ { return observationStartMeas_p; }
+ const casa::ROScalarMeasColumn<casa::MEpoch>& observationEndMeas() const
+ { return observationEndMeas_p; }
+ const casa::ROScalarMeasColumn<casa::MEpoch>& fileDateMeas() const
+ { return fileDateMeas_p; }
+ // </group>
+
+ protected:
+ //# Default constructor creates a object that is not usable. Use the attach
+ //# function correct this.
+ ROMSLofarObservationColumns();
+
+ //# Attach this object to the supplied table.
+ void attach (const MSLofarObservation& msLofarObservation);
+
+ private:
+ //# Make the assignment operator and the copy constructor private to prevent
+ //# any compiler generated one from being used.
+ ROMSLofarObservationColumns(const ROMSLofarObservationColumns&);
+ ROMSLofarObservationColumns& operator=(const ROMSLofarObservationColumns&);
+
+ //# required columns
+ casa::ROScalarColumn<casa::String> projectTitle_p;
+ casa::ROScalarColumn<casa::String> projectPI_p;
+ casa::ROArrayColumn<casa::String> projectCoI_p;
+ casa::ROScalarColumn<casa::String> projectContact_p;
+ casa::ROScalarColumn<casa::String> observationId_p;
+ casa::ROScalarColumn<casa::Double> observationStart_p;
+ casa::ROScalarColumn<casa::Double> observationEnd_p;
+ casa::ROScalarColumn<casa::Double> observationFrequencyMax_p;
+ casa::ROScalarColumn<casa::Double> observationFrequencyMin_p;
+ casa::ROScalarColumn<casa::Double> observationFrequencyCenter_p;
+ casa::ROScalarColumn<casa::Int> subArrayPointing_p;
+ casa::ROScalarColumn<casa::String> antennaSet_p;
+ casa::ROScalarColumn<casa::String> filterSelection_p;
+ casa::ROScalarColumn<casa::Double> clockFrequency_p;
+ casa::ROArrayColumn<casa::String> target_p;
+ casa::ROScalarColumn<casa::String> systemVersion_p;
+ casa::ROScalarColumn<casa::String> pipelineName_p;
+ casa::ROScalarColumn<casa::String> pipelineVersion_p;
+ casa::ROScalarColumn<casa::String> fileName_p;
+ casa::ROScalarColumn<casa::String> fileType_p;
+ casa::ROScalarColumn<casa::Double> fileDate_p;
+ //# Access to Quantum columns
+ casa::ROScalarQuantColumn<casa::Double> observationStartQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> observationEndQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> observationFrequencyMaxQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> observationFrequencyMinQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> observationFrequencyCenterQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> clockFrequencyQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> fileDateQuant_p;
+ //# Access to Measure columns
+ casa::ROScalarMeasColumn<casa::MEpoch> observationStartMeas_p;
+ casa::ROScalarMeasColumn<casa::MEpoch> observationEndMeas_p;
+ casa::ROScalarMeasColumn<casa::MEpoch> fileDateMeas_p;
+ };
+
+
+ // This class provides read/write access to the columns in the MSLofarObservation
+ // Table. It does the declaration of all the Scalar and ArrayColumns with the
+ // correct types, so the application programmer doesn't have to
+ // worry about getting those right. There is an access function
+ // for every predefined column. Access to non-predefined columns will still
+ // have to be done with explicit declarations.
+
+ class MSLofarObservationColumns: public casa::MSObservationColumns
+ {
+ public:
+
+ // Create a columns object that accesses the data in the specified Table.
+ MSLofarObservationColumns(MSLofarObservation& msLofarObservation);
+
+ // The destructor does nothing special.
+ ~MSLofarObservationColumns();
+
+ // Readonly access to columns.
+ // <group>
+ const casa::ROScalarColumn<casa::String>& projectTitle() const
+ { return roProjectTitle_p; }
+ const casa::ROScalarColumn<casa::String>& projectPI() const
+ { return roProjectPI_p; }
+ const casa::ROArrayColumn<casa::String>& projectCoI() const
+ { return roProjectCoI_p; }
+ const casa::ROScalarColumn<casa::String>& projectContact() const
+ { return roProjectContact_p; }
+ const casa::ROScalarColumn<casa::String>& observationId() const
+ { return roObservationId_p; }
+ const casa::ROScalarColumn<casa::Double>& observationStart() const
+ { return roObservationStart_p; }
+ const casa::ROScalarColumn<casa::Double>& observationEnd() const
+ { return roObservationEnd_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyMax() const
+ { return roObservationFrequencyMax_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyMin() const
+ { return roObservationFrequencyMin_p; }
+ const casa::ROScalarColumn<casa::Double>& observationFrequencyCenter() const
+ { return roObservationFrequencyCenter_p; }
+ const casa::ROScalarColumn<casa::Int>& subArrayPointing() const
+ { return roSubArrayPointing_p; }
+ const casa::ROScalarColumn<casa::String>& antennaSet() const
+ { return roAntennaSet_p; }
+ const casa::ROScalarColumn<casa::String>& filterSelection() const
+ { return roFilterSelection_p; }
+ const casa::ROScalarColumn<casa::Double>& clockFrequency() const
+ { return roClockFrequency_p; }
+ const casa::ROArrayColumn<casa::String>& target() const
+ { return roTarget_p; }
+ const casa::ROScalarColumn<casa::String>& systemVersion() const
+ { return roSystemVersion_p; }
+ const casa::ROScalarColumn<casa::String>& pipelineName() const
+ { return roPipelineName_p; }
+ const casa::ROScalarColumn<casa::String>& pipelineVersion() const
+ { return roPipelineVersion_p; }
+ const casa::ROScalarColumn<casa::String>& fileName() const
+ { return roFileName_p; }
+ const casa::ROScalarColumn<casa::String>& fileType() const
+ { return roFileType_p; }
+ const casa::ROScalarColumn<casa::Double>& fileDate() const
+ { return roFileDate_p; }
+ // </group>
+
+ // Readonly access to Quantity columns
+ // <group>
+ const casa::ROScalarQuantColumn<casa::Double>& observationStartQuant() const
+ { return roObservationStartQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationEndQuant() const
+ { return roObservationEndQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyMaxQuant() const
+ { return roObservationFrequencyMaxQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyMinQuant() const
+ { return roObservationFrequencyMinQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& observationFrequencyCenterQuant() const
+ { return roObservationFrequencyCenterQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& clockFrequencyQuant() const
+ { return roClockFrequencyQuant_p; }
+ const casa::ROScalarQuantColumn<casa::Double>& fileDateQuant() const
+ { return roFileDateQuant_p; }
+ // </group>
+
+ // Readonly access to Measure columns
+ // <group>
+ const casa::ROScalarMeasColumn<casa::MEpoch>& observationStartMeas() const
+ { return roObservationStartMeas_p; }
+ const casa::ROScalarMeasColumn<casa::MEpoch>& observationEndMeas() const
+ { return roObservationEndMeas_p; }
+ const casa::ROScalarMeasColumn<casa::MEpoch>& fileDateMeas() const
+ { return roFileDateMeas_p; }
+ // </group>
+
+ // Read/write access to columns.
+ // <group>
+ casa::ScalarColumn<casa::String>& projectTitle()
+ { return rwProjectTitle_p; }
+ casa::ScalarColumn<casa::String>& projectPI()
+ { return rwProjectPI_p; }
+ casa::ArrayColumn<casa::String>& projectCoI()
+ { return rwProjectCoI_p; }
+ casa::ScalarColumn<casa::String>& projectContact()
+ { return rwProjectContact_p; }
+ casa::ScalarColumn<casa::String>& observationId()
+ { return rwObservationId_p; }
+ casa::ScalarColumn<casa::Double>& observationStart()
+ { return rwObservationStart_p; }
+ casa::ScalarColumn<casa::Double>& observationEnd()
+ { return rwObservationEnd_p; }
+ casa::ScalarColumn<casa::Double>& observationFrequencyMax()
+ { return rwObservationFrequencyMax_p; }
+ casa::ScalarColumn<casa::Double>& observationFrequencyMin()
+ { return rwObservationFrequencyMin_p; }
+ casa::ScalarColumn<casa::Double>& observationFrequencyCenter()
+ { return rwObservationFrequencyCenter_p; }
+ casa::ScalarColumn<casa::Int>& subArrayPointing()
+ { return rwSubArrayPointing_p; }
+ casa::ScalarColumn<casa::String>& antennaSet()
+ { return rwAntennaSet_p; }
+ casa::ScalarColumn<casa::String>& filterSelection()
+ { return rwFilterSelection_p; }
+ casa::ScalarColumn<casa::Double>& clockFrequency()
+ { return rwClockFrequency_p; }
+ casa::ArrayColumn<casa::String>& target()
+ { return rwTarget_p; }
+ casa::ScalarColumn<casa::String>& systemVersion()
+ { return rwSystemVersion_p; }
+ casa::ScalarColumn<casa::String>& pipelineName()
+ { return rwPipelineName_p; }
+ casa::ScalarColumn<casa::String>& pipelineVersion()
+ { return rwPipelineVersion_p; }
+ casa::ScalarColumn<casa::String>& fileName()
+ { return rwFileName_p; }
+ casa::ScalarColumn<casa::String>& fileType()
+ { return rwFileType_p; }
+ casa::ScalarColumn<casa::Double>& fileDate()
+ { return rwFileDate_p; }
+ // </group>
+
+ // Read/write access to Quantity columns
+ // <group>
+ casa::ScalarQuantColumn<casa::Double>& observationStartQuant()
+ { return rwObservationStartQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& observationEndQuant()
+ { return rwObservationEndQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& observationFrequencyMaxQuant()
+ { return rwObservationFrequencyMaxQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& observationFrequencyMinQuant()
+ { return rwObservationFrequencyMinQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& observationFrequencyCenterQuant()
+ { return rwObservationFrequencyCenterQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& clockFrequencyQuant()
+ { return rwClockFrequencyQuant_p; }
+ casa::ScalarQuantColumn<casa::Double>& fileDateQuant()
+ { return rwFileDateQuant_p; }
+ // </group>
+
+ // Read/write access to Measure columns
+ // <group>
+ casa::ScalarMeasColumn<casa::MEpoch>& observationStartMeas()
+ { return rwObservationStartMeas_p; }
+ casa::ScalarMeasColumn<casa::MEpoch>& observationEndMeas()
+ { return rwObservationEndMeas_p; }
+ casa::ScalarMeasColumn<casa::MEpoch>& fileDateMeas()
+ { return rwFileDateMeas_p; }
+ // </group>
+
+ protected:
+ //# Default constructor creates a object that is not usable. Use the attach
+ //# function correct this.
+ MSLofarObservationColumns();
+
+ //# Attach this object to the supplied table.
+ void attach(MSLofarObservation& msLofarObservation);
+
+ private:
+ //# Make the assignment operator and the copy constructor private to prevent
+ //# any compiler generated one from being used.
+ MSLofarObservationColumns(const MSLofarObservationColumns&);
+ MSLofarObservationColumns& operator=(const MSLofarObservationColumns&);
+
+ //# required columns
+ casa::ROScalarColumn<casa::String> roProjectTitle_p;
+ casa::ROScalarColumn<casa::String> roProjectPI_p;
+ casa::ROArrayColumn<casa::String> roProjectCoI_p;
+ casa::ROScalarColumn<casa::String> roProjectContact_p;
+ casa::ROScalarColumn<casa::String> roObservationId_p;
+ casa::ROScalarColumn<casa::Double> roObservationStart_p;
+ casa::ROScalarColumn<casa::Double> roObservationEnd_p;
+ casa::ROScalarColumn<casa::Double> roObservationFrequencyMax_p;
+ casa::ROScalarColumn<casa::Double> roObservationFrequencyMin_p;
+ casa::ROScalarColumn<casa::Double> roObservationFrequencyCenter_p;
+ casa::ROScalarColumn<casa::Int> roSubArrayPointing_p;
+ casa::ROScalarColumn<casa::String> roAntennaSet_p;
+ casa::ROScalarColumn<casa::String> roFilterSelection_p;
+ casa::ROScalarColumn<casa::Double> roClockFrequency_p;
+ casa::ROArrayColumn<casa::String> roTarget_p;
+ casa::ROScalarColumn<casa::String> roSystemVersion_p;
+ casa::ROScalarColumn<casa::String> roPipelineName_p;
+ casa::ROScalarColumn<casa::String> roPipelineVersion_p;
+ casa::ROScalarColumn<casa::String> roFileName_p;
+ casa::ROScalarColumn<casa::String> roFileType_p;
+ casa::ROScalarColumn<casa::Double> roFileDate_p;
+ //# Access to Quantum columns
+ casa::ROScalarQuantColumn<casa::Double> roObservationStartQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roObservationEndQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roObservationFrequencyMaxQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roObservationFrequencyMinQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roObservationFrequencyCenterQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roClockFrequencyQuant_p;
+ casa::ROScalarQuantColumn<casa::Double> roFileDateQuant_p;
+ //# Access to Measure columns
+ casa::ROScalarMeasColumn<casa::MEpoch> roObservationStartMeas_p;
+ casa::ROScalarMeasColumn<casa::MEpoch> roObservationEndMeas_p;
+ casa::ROScalarMeasColumn<casa::MEpoch> roFileDateMeas_p;
+ //# required columns
+ casa::ScalarColumn<casa::String> rwProjectTitle_p;
+ casa::ScalarColumn<casa::String> rwProjectPI_p;
+ casa::ArrayColumn<casa::String> rwProjectCoI_p;
+ casa::ScalarColumn<casa::String> rwProjectContact_p;
+ casa::ScalarColumn<casa::String> rwObservationId_p;
+ casa::ScalarColumn<casa::Double> rwObservationStart_p;
+ casa::ScalarColumn<casa::Double> rwObservationEnd_p;
+ casa::ScalarColumn<casa::Double> rwObservationFrequencyMax_p;
+ casa::ScalarColumn<casa::Double> rwObservationFrequencyMin_p;
+ casa::ScalarColumn<casa::Double> rwObservationFrequencyCenter_p;
+ casa::ScalarColumn<casa::Int> rwSubArrayPointing_p;
+ casa::ScalarColumn<casa::String> rwAntennaSet_p;
+ casa::ScalarColumn<casa::String> rwFilterSelection_p;
+ casa::ScalarColumn<casa::Double> rwClockFrequency_p;
+ casa::ArrayColumn<casa::String> rwTarget_p;
+ casa::ScalarColumn<casa::String> rwSystemVersion_p;
+ casa::ScalarColumn<casa::String> rwPipelineName_p;
+ casa::ScalarColumn<casa::String> rwPipelineVersion_p;
+ casa::ScalarColumn<casa::String> rwFileName_p;
+ casa::ScalarColumn<casa::String> rwFileType_p;
+ casa::ScalarColumn<casa::Double> rwFileDate_p;
+ //# Access to Quantum columns
+ casa::ScalarQuantColumn<casa::Double> rwObservationStartQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwObservationEndQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwObservationFrequencyMaxQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwObservationFrequencyMinQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwObservationFrequencyCenterQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwClockFrequencyQuant_p;
+ casa::ScalarQuantColumn<casa::Double> rwFileDateQuant_p;
+ //# Access to Measure columns
+ casa::ScalarMeasColumn<casa::MEpoch> rwObservationStartMeas_p;
+ casa::ScalarMeasColumn<casa::MEpoch> rwObservationEndMeas_p;
+ casa::ScalarMeasColumn<casa::MEpoch> rwFileDateMeas_p;
+ };
+
+} //# end namespace
+
+#endif
diff --git a/LCS/MSLofar/include/MSLofar/MSLofarObservation.h b/LCS/MSLofar/include/MSLofar/MSLofarObservation.h
new file mode 100644
index 0000000000000000000000000000000000000000..e12ce16382526f64be6b44320ae54f8c5b0477bf
--- /dev/null
+++ b/LCS/MSLofar/include/MSLofar/MSLofarObservation.h
@@ -0,0 +1,65 @@
+//# MSLofarObservation.h: LOFAR MS OBSERVATION_FIELD subtable
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#ifndef MSLOFAR_MSLOFAROBSERVATION_H
+#define MSLOFAR_MSLOFAROBSERVATION_H
+
+#include <ms/MeasurementSets/MSObservation.h>
+#include <MSLofar/MSLofarTable.h>
+
+namespace LOFAR {
+
+ class MSLofarObservation: public casa::MSObservation
+ {
+ public:
+
+ // Default constructor creates an unusable object.
+ MSLofarObservation();
+
+ // Create from an existing table.
+ MSLofarObservation (const casa::String& tableName,
+ casa::Table::TableOption option);
+
+ // Create a new table.
+ MSLofarObservation (casa::SetupNewTable& newTab, casa::uInt nrrow,
+ casa::Bool initialize);
+
+ // Create from an existing Table object.
+ MSLofarObservation (const casa::Table& table);
+
+ // Copy constructor (reference semnatics).
+ MSLofarObservation (const MSLofarObservation& that);
+
+ // The destructor flushes the table if not done yet.
+ ~MSLofarObservation();
+
+ // Assignment (reference semantics).
+ MSLofarObservation& operator= (const MSLofarObservation& that);
+
+ // Create the table description containing the required columns.
+ static casa::TableDesc requiredTableDesc();
+ };
+
+} //# end namespace
+
+#endif
diff --git a/LCS/MSLofar/src/BeamTables.cc b/LCS/MSLofar/src/BeamTables.cc
index e7607e31eb38c66fdb07db3d95cef232fd85c0aa..0fd9334f9fa3091cd9c8eaf5666ea2886b427a78 100644
--- a/LCS/MSLofar/src/BeamTables.cc
+++ b/LCS/MSLofar/src/BeamTables.cc
@@ -122,10 +122,12 @@ void BeamTables::create (Table& ms,
blitz::Array<double,2> hbaOffsets; // offsets of HBA dipoles in a tile
bool done = false;
int firstHbaOffset = 0;
- if (antFieldName == "HBA") {
+ if (antFieldType == "HBA") {
// Get the offsets of HBA dipoles w.r.t. tile center.
hbaOffsets.reference (getHBADeltas (hbaDeltaPath + stationName +
"-iHBADeltas.conf"));
+ }
+ if (antFieldName == "HBA") {
// HBA can be split into HBA0 and HBA1.
// They have to be written separately.
if (antFieldName == "HBA") {
diff --git a/LCS/MSLofar/src/CMakeLists.txt b/LCS/MSLofar/src/CMakeLists.txt
index 7d0fd2c75f2a28fbcc58772b14d898180e9faeb4..b24b955e824ece802e99d9191c3b6090f89e8358 100644
--- a/LCS/MSLofar/src/CMakeLists.txt
+++ b/LCS/MSLofar/src/CMakeLists.txt
@@ -9,6 +9,10 @@ lofar_add_library(mslofar
MSAntennaFieldColumns.cc
MSElementFailure.cc
MSElementFailureColumns.cc
+ MSLofarAntenna.cc
+ MSLofarAntennaColumns.cc
+ MSLofarObservation.cc
+ MSLofarObsColumns.cc
MSStation.cc
MSStationColumns.cc
BeamTables.cc
diff --git a/LCS/MSLofar/src/MSLofar.cc b/LCS/MSLofar/src/MSLofar.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1ce628d1e12ad488002da3b03f382bee887d0b35
--- /dev/null
+++ b/LCS/MSLofar/src/MSLofar.cc
@@ -0,0 +1,418 @@
+//# MSLofar.cc: Class handling a LOFAR MeasurementSet
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#include<lofar_config.h>
+#include <MSLofar/MSLofar.h
+
+
+namespace LOFAR {
+
+ MeasurementSet::MeasurementSet()
+ {}
+
+ MeasurementSet::MeasurementSet(const String &tableName,
+ TableOption option)
+ : MeasurementSet (tableName, option);
+ {
+ initRefs();
+ }
+
+ MeasurementSet::MeasurementSet(const String &tableName,
+ const TableLock& lockOptions,
+ TableOption option)
+ : MeasurementSet (tableName, lockOptions, option);
+ {
+ initRefs();
+ }
+
+ MeasurementSet::MeasurementSet(SetupNewTable &newTab, uInt nrrow,
+ Bool initialize)
+ : MeasurementSet (newTab, nrrow, initialize);
+ {}
+
+ MeasurementSet::MeasurementSet(SetupNewTable &newTab,
+ const TableLock& lockOptions, uInt nrrow,
+ Bool initialize)
+ : MeasurementSet (newTab, lockOptions, nrrow, initialize);
+ {}
+
+ MeasurementSet::MeasurementSet(const Table &table)
+ : MeasurementSet (table)
+ {
+ initRefs();
+ }
+
+ MeasurementSet::MeasurementSet(const MeasurementSet &other)
+ : MeasurementSet (other)
+ {
+ if (!isNull()) initRefs();
+ }
+
+ MeasurementSet::~MeasurementSet()
+ {}
+
+ MeasurementSet& MeasurementSet::operator=(const MeasurementSet &other)
+{
+ if (&other != this) {
+ MeasurementSet::operator= (other);
+ if (!isNull()) initRefs(True);
+ }
+ return *this;
+}
+
+
+ MeasurementSet MeasurementSet::referenceCopy(const String& newTableName,
+ const Block<String>& writableColumns) const
+ {
+ return MSLofar (MeasurementSet::referenceCopy (newTableName,
+ writableColumns));
+ }
+
+
+void MeasurementSet::initRefs(Bool clear)
+{
+ if (isNull()||clear) {
+ // clear subtable references
+ antenna_p=MSAntenna();
+ dataDesc_p=MSDataDescription();
+ doppler_p=MSDoppler();
+ feed_p=MSFeed();
+ field_p=MSField();
+ flagCmd_p=MSFlagCmd();
+ freqOffset_p=MSFreqOffset();
+ history_p=MSHistory();
+ observation_p=MSObservation();
+ pointing_p=MSPointing();
+ polarization_p=MSPolarization();
+ processor_p=MSProcessor();
+ source_p=MSSource();
+ spectralWindow_p=MSSpectralWindow();
+ state_p=MSState();
+ sysCal_p=MSSysCal();
+ weather_p=MSWeather();
+ }
+ if (!isNull()) {
+ // write the table info if needed
+ if (this->tableInfo().type()=="") {
+ String reqdType=this->tableInfo().type(TableInfo::MEASUREMENTSET);
+ this->tableInfo().setType(reqdType);
+ String reqdSubType=this->tableInfo().subType(TableInfo::MEASUREMENTSET);
+ this->tableInfo().setSubType(reqdSubType);
+ this->tableInfo().readmeAddLine("This is a MeasurementSet Table"
+ " holding measurements from a Telescope");
+ }
+ if(this->tableOption() != Table::Scratch){
+ if (this->keywordSet().isDefined("ANTENNA"))
+ antenna_p=MSAntenna(this->keywordSet().asTable("ANTENNA", mainLock_p));
+ if (this->keywordSet().isDefined("DATA_DESCRIPTION"))
+ dataDesc_p=MSDataDescription(this->keywordSet().
+ asTable("DATA_DESCRIPTION", mainLock_p));
+ if (this->keywordSet().isDefined("DOPPLER"))
+ doppler_p=MSDoppler(this->keywordSet().asTable("DOPPLER", mainLock_p));
+ if (this->keywordSet().isDefined("FEED"))
+ feed_p=MSFeed(this->keywordSet().asTable("FEED", mainLock_p));
+ if (this->keywordSet().isDefined("FIELD"))
+ field_p=MSField(this->keywordSet().asTable("FIELD", mainLock_p));
+ if (this->keywordSet().isDefined("FLAG_CMD"))
+ flagCmd_p=MSFlagCmd(this->keywordSet().asTable("FLAG_CMD",
+ mainLock_p));
+ if (this->keywordSet().isDefined("FREQ_OFFSET"))
+ freqOffset_p=MSFreqOffset(this->keywordSet().
+ asTable("FREQ_OFFSET", mainLock_p));
+ if (this->keywordSet().isDefined("HISTORY"))
+ history_p=MSHistory(this->keywordSet().asTable("HISTORY", mainLock_p));
+ if (this->keywordSet().isDefined("OBSERVATION"))
+ observation_p=MSObservation(this->keywordSet().
+ asTable("OBSERVATION",mainLock_p));
+ if (this->keywordSet().isDefined("POINTING"))
+ pointing_p=MSPointing(this->keywordSet().
+ asTable("POINTING", mainLock_p));
+ if (this->keywordSet().isDefined("POLARIZATION"))
+ polarization_p=MSPolarization(this->keywordSet().
+ asTable("POLARIZATION",mainLock_p));
+ if (this->keywordSet().isDefined("PROCESSOR"))
+ processor_p=MSProcessor(this->keywordSet().
+ asTable("PROCESSOR", mainLock_p));
+ if (this->keywordSet().isDefined("SOURCE"))
+ source_p=MSSource(this->keywordSet().asTable("SOURCE", mainLock_p));
+ if (this->keywordSet().isDefined("SPECTRAL_WINDOW"))
+ spectralWindow_p=MSSpectralWindow(this->keywordSet().
+ asTable("SPECTRAL_WINDOW",mainLock_p));
+ if (this->keywordSet().isDefined("STATE"))
+ state_p=MSState(this->keywordSet().asTable("STATE", mainLock_p));
+ if (this->keywordSet().isDefined("SYSCAL"))
+ sysCal_p=MSSysCal(this->keywordSet().asTable("SYSCAL", mainLock_p));
+ if (this->keywordSet().isDefined("WEATHER"))
+ weather_p=MSWeather(this->keywordSet().asTable("WEATHER", mainLock_p));
+ }
+ else{ //if its scratch...don't bother about the lock as
+ //We can't close and reopen subtables hence we can't use the version
+ //of astable that does that.
+ if (this->keywordSet().isDefined("ANTENNA"))
+ antenna_p=MSAntenna(this->keywordSet().asTable("ANTENNA"));
+ if (this->keywordSet().isDefined("DATA_DESCRIPTION"))
+ dataDesc_p=MSDataDescription(this->keywordSet().
+ asTable("DATA_DESCRIPTION"));
+ if (this->keywordSet().isDefined("DOPPLER"))
+ doppler_p=MSDoppler(this->keywordSet().asTable("DOPPLER"));
+ if (this->keywordSet().isDefined("FEED"))
+ feed_p=MSFeed(this->keywordSet().asTable("FEED"));
+ if (this->keywordSet().isDefined("FIELD"))
+ field_p=MSField(this->keywordSet().asTable("FIELD"));
+ if (this->keywordSet().isDefined("FLAG_CMD"))
+ flagCmd_p=MSFlagCmd(this->keywordSet().asTable("FLAG_CMD"));
+ if (this->keywordSet().isDefined("FREQ_OFFSET"))
+ freqOffset_p=MSFreqOffset(this->keywordSet().
+ asTable("FREQ_OFFSET"));
+ if (this->keywordSet().isDefined("HISTORY"))
+ history_p=MSHistory(this->keywordSet().asTable("HISTORY"));
+ if (this->keywordSet().isDefined("OBSERVATION"))
+ observation_p=MSObservation(this->keywordSet().
+ asTable("OBSERVATION"));
+ if (this->keywordSet().isDefined("POINTING"))
+ pointing_p=MSPointing(this->keywordSet().
+ asTable("POINTING"));
+ if (this->keywordSet().isDefined("POLARIZATION"))
+ polarization_p=MSPolarization(this->keywordSet().
+ asTable("POLARIZATION"));
+ if (this->keywordSet().isDefined("PROCESSOR"))
+ processor_p=MSProcessor(this->keywordSet().
+ asTable("PROCESSOR"));
+ if (this->keywordSet().isDefined("SOURCE"))
+ source_p=MSSource(this->keywordSet().asTable("SOURCE"));
+ if (this->keywordSet().isDefined("SPECTRAL_WINDOW"))
+ spectralWindow_p=MSSpectralWindow(this->keywordSet().
+ asTable("SPECTRAL_WINDOW"));
+ if (this->keywordSet().isDefined("STATE"))
+ state_p=MSState(this->keywordSet().asTable("STATE"));
+ if (this->keywordSet().isDefined("SYSCAL"))
+ sysCal_p=MSSysCal(this->keywordSet().asTable("SYSCAL"));
+ if (this->keywordSet().isDefined("WEATHER"))
+ weather_p=MSWeather(this->keywordSet().asTable("WEATHER"));
+
+
+ }
+ }
+}
+
+void MeasurementSet::createDefaultSubtables(Table::TableOption option)
+{
+ SetupNewTable antennaSetup(antennaTableName(),
+ MSAntenna::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::ANTENNA),
+ Table(antennaSetup));
+ SetupNewTable dataDescSetup(dataDescriptionTableName(),
+ MSDataDescription::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::DATA_DESCRIPTION),
+ Table(dataDescSetup));
+ SetupNewTable feedSetup(feedTableName(),
+ MSFeed::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::FEED), Table(feedSetup));
+ SetupNewTable flagCmdSetup(flagCmdTableName(),
+ MSFlagCmd::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::FLAG_CMD),
+ Table(flagCmdSetup));
+ SetupNewTable fieldSetup(fieldTableName(),
+ MSField::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::FIELD), Table(fieldSetup));
+ SetupNewTable historySetup(historyTableName(),
+ MSHistory::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::HISTORY),
+ Table(historySetup));
+ SetupNewTable observationSetup(observationTableName(),
+ MSObservation::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::OBSERVATION),
+ Table(observationSetup));
+ SetupNewTable pointingSetup(pointingTableName(),
+ MSPointing::requiredTableDesc(),option);
+ // Pointing table can be large, set some sensible defaults for storageMgrs
+ IncrementalStMan ismPointing ("ISMPointing");
+ StandardStMan ssmPointing("SSMPointing",32768);
+ pointingSetup.bindAll(ismPointing,True);
+ pointingSetup.bindColumn(MSPointing::columnName(MSPointing::ANTENNA_ID),
+ ssmPointing);
+ rwKeywordSet().defineTable(MS::keywordName(MS::POINTING),
+ Table(pointingSetup));
+ SetupNewTable polarizationSetup(polarizationTableName(),
+ MSPolarization::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::POLARIZATION),
+ Table(polarizationSetup));
+ SetupNewTable processorSetup(processorTableName(),
+ MSProcessor::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::PROCESSOR),
+ Table(processorSetup));
+ SetupNewTable spectralWindowSetup(spectralWindowTableName(),
+ MSSpectralWindow::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::SPECTRAL_WINDOW),
+ Table(spectralWindowSetup));
+ SetupNewTable stateSetup(stateTableName(),
+ MSState::requiredTableDesc(),option);
+ rwKeywordSet().defineTable(MS::keywordName(MS::STATE),
+ Table(stateSetup));
+ initRefs();
+}
+
+Bool MeasurementSet::makeComplexData()
+{
+ // for now we use an extremely simplistic implementation (should find out
+ // storage managers and tiles and keep things the same)
+ if (tableDesc().isColumn(MS::columnName(MS::DATA))) return False;
+ if (!tableDesc().isColumn(MS::columnName(MS::FLOAT_DATA))) return False;
+
+ // we have FLOAT_DATA but not DATA
+ // add DATA
+ addColumn(ArrayColumnDesc<Complex>("DATA",2));
+
+ // now copy data across from FLOAT_DATA
+ ArrayColumn<Float> floatData(*this,MS::columnName(MS::FLOAT_DATA));
+ ArrayColumn<Complex> data(*this,MS::columnName(MS::DATA));
+ for (uInt i=0; i<nrow(); i++) {
+ Array<Float> floatArr(floatData(i));
+ Array<Complex> dataArr(floatArr.shape());
+ convertArray(dataArr,floatArr);
+ data.put(i,dataArr);
+ }
+ return True;
+}
+
+Bool MeasurementSet::validateMeasureRefs()
+{
+ Bool ok=True;
+ // check main table
+ {
+ Int nCol = tableDesc().ncolumn();
+ for (Int i=0; i<nCol; i++) {
+ Int fld = tableDesc()[i].keywordSet().fieldNumber("MEASINFO");
+ if (fld>=0) {
+ Int refFld = tableDesc()[i].keywordSet().asRecord(fld).
+ fieldNumber("Ref");
+ if (refFld<0 || tableDesc()[i].keywordSet().asRecord(fld).
+ asString(refFld) == "") {
+ cerr << "Missing Measure reference for column "<<tableDesc()[i].name()
+ << endl;
+ ok = False;
+ }
+ }
+ }
+ }
+ // check all subtables
+ Int nKey = keywordSet().nfields();
+ for (Int i=0; i<nKey; i++) {
+ if (keywordSet().type(i)== TpTable) {
+ Table tab = keywordSet().asTable(i);
+ Int nCol = tab.tableDesc().ncolumn();
+ for (Int i=0; i<nCol; i++) {
+ Int fld = tab.tableDesc()[i].keywordSet().fieldNumber("MEASINFO");
+ if (fld>=0) {
+ Int refFld = tab.tableDesc()[i].keywordSet().asRecord(fld).
+ fieldNumber("Ref");
+ if (refFld<0 || tab.tableDesc()[i].keywordSet().asRecord(fld).
+ asString(refFld) == "") {
+ cerr << "Missing Measure reference for column "
+ <<tab.tableDesc()[i].name()<<" in subtable "<<tab.tableName()
+ << endl;
+ ok = False;
+ }
+ }
+ }
+ }
+ }
+ return ok;
+}
+
+void MeasurementSet::flush(Bool sync) {
+ MSTable<MSMainEnums::PredefinedColumns, MSMainEnums::PredefinedKeywords>::flush(sync);
+ antenna_p.flush(sync);
+ dataDesc_p.flush(sync);
+ if (!doppler_p.isNull()) doppler_p.flush(sync);
+ feed_p.flush(sync);
+ field_p.flush(sync);
+ flagCmd_p.flush(sync);
+ if (!freqOffset_p.isNull()) freqOffset_p.flush(sync);
+ history_p.flush(sync);
+ observation_p.flush(sync);
+ pointing_p.flush(sync);
+ polarization_p.flush(sync);
+ processor_p.flush(sync);
+ if (!source_p.isNull()) source_p.flush(sync);
+ spectralWindow_p.flush(sync);
+ state_p.flush(sync);
+ if (!sysCal_p.isNull()) sysCal_p.flush(sync);
+ if (!weather_p.isNull()) weather_p.flush(sync);
+}
+
+void MeasurementSet::checkVersion()
+{
+ // Check that the MS is the latest version (2.0). Throw an
+ // exception and advise the user to use the MS converter if it is not.
+ //
+ if (!keywordSet().isDefined("MS_VERSION") ||
+ (keywordSet().isDefined("MS_VERSION") &&
+ keywordSet().asFloat("MS_VERSION")!=2.0)) {
+ throw(AipsError("These data are not in MSv2 format - use ms1toms2 to convert"));
+ }
+}
+
+Record MeasurementSet::msseltoindex(const String& spw, const String& field,
+ const String& baseline, const String& time,
+ const String& scan, const String& uvrange,
+ const String& taql){
+ Record retval;
+ MSSelection thisSelection;
+ thisSelection.setSpwExpr(spw);
+ thisSelection.setFieldExpr(field);
+ thisSelection.setAntennaExpr(baseline);
+ thisSelection.setTimeExpr(time);
+ thisSelection.setScanExpr(scan);
+ thisSelection.setUvDistExpr(uvrange);
+ thisSelection.setTaQLExpr(taql);
+ TableExprNode exprNode=thisSelection.toTableExprNode(this);
+ Vector<Int> fieldlist=thisSelection.getFieldList();
+ Vector<Int> spwlist=thisSelection.getSpwList();
+ Vector<Int> scanlist=thisSelection.getScanList();
+ Vector<Int> antenna1list=thisSelection.getAntenna1List();
+ Vector<Int> antenna2list=thisSelection.getAntenna2List();
+ Matrix<Int> chanlist=thisSelection.getChanList();
+ Matrix<Int> baselinelist=thisSelection.getBaselineList();
+ Vector<Int> ddIDList=thisSelection.getDDIDList();
+ OrderedMap<Int, Vector<Int > > polMap=thisSelection.getPolMap();
+ OrderedMap<Int, Vector<Vector<Int> > > corrMap=thisSelection.getCorrMap();
+
+ retval.define("spw", spwlist);
+ retval.define("field", fieldlist);
+ retval.define("scan",scanlist);
+ retval.define("antenna1", antenna1list);
+ retval.define("antenna2", antenna2list);
+ retval.define("baselines",baselinelist);
+ retval.define("channel", chanlist);
+ retval.define("dd",ddIDList);
+ // retval.define("polmap",polMap);
+ // retrval.define("corrmap",corrMap);
+
+ return retval;
+
+}
+
+
+} //# NAMESPACE CASA - END
+
diff --git a/LCS/MSLofar/src/MSLofarAntenna.cc b/LCS/MSLofar/src/MSLofarAntenna.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9ae225a767424230e1705e808fad94a02926d1cc
--- /dev/null
+++ b/LCS/MSLofar/src/MSLofarAntenna.cc
@@ -0,0 +1,75 @@
+//# MSLofarAntenna.cc: MS ANTENNA subtable with LOFAR extensions
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#include <lofar_config.h>
+#include <MSLofar/MSLofarAntenna.h>
+#include <measures/Measures/MPosition.h>
+
+using namespace casa;
+
+namespace LOFAR {
+
+ MSLofarAntenna::MSLofarAntenna()
+ {}
+
+ MSLofarAntenna::MSLofarAntenna (const String& tableName,
+ Table::TableOption option)
+ : MSAntenna (tableName, option)
+ {}
+
+ MSLofarAntenna::MSLofarAntenna (SetupNewTable& newTab, uInt nrrow,
+ Bool initialize)
+ : MSAntenna (newTab, nrrow, initialize)
+ {}
+
+ MSLofarAntenna::MSLofarAntenna (const Table& table)
+ : MSAntenna (table)
+ {}
+
+ MSLofarAntenna::MSLofarAntenna (const MSLofarAntenna& that)
+ : MSAntenna (that)
+ {}
+
+ MSLofarAntenna::~MSLofarAntenna()
+ {}
+
+ MSLofarAntenna& MSLofarAntenna::operator= (const MSLofarAntenna& that)
+ {
+ MSAntenna::operator= (that);
+ return *this;
+ }
+
+ TableDesc MSLofarAntenna::requiredTableDesc()
+ {
+ TableDesc td (MSAntenna::requiredTableDesc());
+ MSLofarTable::addColumn (td, "LOFAR_STATION_ID", TpInt,
+ "ID in LOFAR_STATION table");
+ MSLofarTable::addColumn (td, "LOFAR_PHASE_REFERENCE", TpArrayDouble,
+ "Beamformer phase reference position",
+ "m", "POSITION", MPosition::ITRF,
+ 1, IPosition(1,3),
+ ColumnDesc::FixedShape + ColumnDesc::Direct);
+ return td;
+ }
+
+} //# end namespace
diff --git a/LCS/MSLofar/src/MSLofarAntennaColumns.cc b/LCS/MSLofar/src/MSLofarAntennaColumns.cc
new file mode 100644
index 0000000000000000000000000000000000000000..09d2e1edd190ea734e055e4f26f67e96404be610
--- /dev/null
+++ b/LCS/MSLofar/src/MSLofarAntennaColumns.cc
@@ -0,0 +1,81 @@
+//# MSLofarAntennaColumns.cc: provides easy access to LOFAR's MSAntenna columns
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#include <lofar_config.h>
+#include <MSLofar/MSLofarAntennaColumns.h>
+#include <MSLofar/MSLofarAntenna.h>
+
+using namespace casa;
+
+namespace LOFAR {
+
+ ROMSLofarAntennaColumns::ROMSLofarAntennaColumns
+ (const MSLofarAntenna& msLofarAntenna)
+ {
+ attach (msLofarAntenna);
+ }
+
+ ROMSLofarAntennaColumns::~ROMSLofarAntennaColumns()
+ {}
+
+ ROMSLofarAntennaColumns::ROMSLofarAntennaColumns()
+ {}
+
+ void ROMSLofarAntennaColumns::attach
+ (const MSLofarAntenna& msLofarAntenna)
+ {
+ ROMSAntennaColumns::attach (msLofarAntenna);
+ stationId_p.attach (msLofarAntenna, "LOFAR_STATION_ID");
+ phaseReference_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ phaseReferenceQuant_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ phaseReferenceMeas_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ }
+
+
+ MSLofarAntennaColumns::MSLofarAntennaColumns
+ (MSLofarAntenna& msLofarAntenna)
+ {
+ attach (msLofarAntenna);
+ }
+
+ MSLofarAntennaColumns::~MSLofarAntennaColumns()
+ {}
+
+ MSLofarAntennaColumns::MSLofarAntennaColumns()
+ {}
+
+ void MSLofarAntennaColumns::attach
+ (MSLofarAntenna& msLofarAntenna)
+ {
+ MSAntennaColumns::attach (msLofarAntenna);
+ roStationId_p.attach (msLofarAntenna, "LOFAR_STATION_ID");
+ rwStationId_p.attach (msLofarAntenna, "LOFAR_STATION_ID");
+ roPhaseReference_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ rwPhaseReference_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ roPhaseReferenceQuant_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ rwPhaseReferenceQuant_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ roPhaseReferenceMeas_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ rwPhaseReferenceMeas_p.attach (msLofarAntenna, "LOFAR_PHASE_REFERENCE");
+ }
+
+} //# end namespace
diff --git a/LCS/MSLofar/src/MSLofarObsColumns.cc b/LCS/MSLofar/src/MSLofarObsColumns.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8067965d58b1dd2c30c582a37e3fd525126780ea
--- /dev/null
+++ b/LCS/MSLofar/src/MSLofarObsColumns.cc
@@ -0,0 +1,164 @@
+//# MSLofarObsColumns.cc: provides easy access to LOFAR's MSObservation columns
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#include <lofar_config.h>
+#include <MSLofar/MSLofarObsColumns.h>
+#include <MSLofar/MSLofarObservation.h>
+
+using namespace casa;
+
+namespace LOFAR {
+
+ ROMSLofarObservationColumns::ROMSLofarObservationColumns
+ (const MSLofarObservation& msLofarObservation)
+ {
+ attach (msLofarObservation);
+ }
+
+ ROMSLofarObservationColumns::~ROMSLofarObservationColumns()
+ {}
+
+ ROMSLofarObservationColumns::ROMSLofarObservationColumns()
+ {}
+
+ void ROMSLofarObservationColumns::attach
+ (const MSLofarObservation& msLofarObservation)
+ {
+ ROMSObservationColumns::attach (msLofarObservation);
+ projectTitle_p.attach (msLofarObservation, "LOFAR_PROJECT_TITLE");
+ projectPI_p.attach (msLofarObservation, "LOFAR_PROJECT_PI");
+ projectCoI_p.attach (msLofarObservation, "LOFAR_PROJECT_CO_I");
+ projectContact_p.attach (msLofarObservation, "LOFAR_PROJECT_CONTACT");
+ observationId_p.attach (msLofarObservation, "LOFAR_OBSERVATION_ID");
+ observationStart_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ observationEnd_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ observationFrequencyMax_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ observationFrequencyMin_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ observationFrequencyCenter_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ subArrayPointing_p.attach (msLofarObservation, "LOFAR_SUB_ARRAY_POINTING");
+ antennaSet_p.attach (msLofarObservation, "LOFAR_ANTENNA_SET");
+ filterSelection_p.attach (msLofarObservation, "LOFAR_FILTER_SELECTION");
+ clockFrequency_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ target_p.attach (msLofarObservation, "LOFAR_TAGET");
+ systemVersion_p.attach (msLofarObservation, "LOFAR_SYSTEM_VERSION");
+ pipelineName_p.attach (msLofarObservation, "LOFAR_PIPELINE_NAME");
+ pipelineVersion_p.attach (msLofarObservation, "LOFAR_PIPELINE_VERSION");
+ fileName_p.attach (msLofarObservation, "LOFAR_FILE_NAME");
+ fileType_p.attach (msLofarObservation, "LOFAR_FILE_TYPE");
+ fileDate_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ observationStartQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ observationEndQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ observationFrequencyMaxQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ observationFrequencyMinQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ observationFrequencyCenterQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ clockFrequencyQuant_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ fileDateQuant_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ observationStartMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ observationEndMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ fileDateMeas_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ }
+
+
+ MSLofarObservationColumns::MSLofarObservationColumns
+ (MSLofarObservation& msLofarObservation)
+ {
+ attach (msLofarObservation);
+ }
+
+ MSLofarObservationColumns::~MSLofarObservationColumns()
+ {}
+
+ MSLofarObservationColumns::MSLofarObservationColumns()
+ {}
+
+ void MSLofarObservationColumns::attach
+ (MSLofarObservation& msLofarObservation)
+ {
+ MSObservationColumns::attach (msLofarObservation);
+ // Readonly.
+ roProjectTitle_p.attach (msLofarObservation, "LOFAR_PROJECT_TITLE");
+ roProjectPI_p.attach (msLofarObservation, "LOFAR_PROJECT_PI");
+ roProjectCoI_p.attach (msLofarObservation, "LOFAR_PROJECT_CO_I");
+ roProjectContact_p.attach (msLofarObservation, "LOFAR_PROJECT_CONTACT");
+ roObservationId_p.attach (msLofarObservation, "LOFAR_OBSERVATION_ID");
+ roObservationStart_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ roObservationEnd_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ roObservationFrequencyMax_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ roObservationFrequencyMin_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ roObservationFrequencyCenter_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ roSubArrayPointing_p.attach (msLofarObservation, "LOFAR_SUB_ARRAY_POINTING");
+ roAntennaSet_p.attach (msLofarObservation, "LOFAR_ANTENNA_SET");
+ roFilterSelection_p.attach (msLofarObservation, "LOFAR_FILTER_SELECTION");
+ roClockFrequency_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ roTarget_p.attach (msLofarObservation, "LOFAR_TAGET");
+ roSystemVersion_p.attach (msLofarObservation, "LOFAR_SYSTEM_VERSION");
+ roPipelineName_p.attach (msLofarObservation, "LOFAR_PIPELINE_NAME");
+ roPipelineVersion_p.attach (msLofarObservation, "LOFAR_PIPELINE_VERSION");
+ roFileName_p.attach (msLofarObservation, "LOFAR_FILE_NAME");
+ roFileType_p.attach (msLofarObservation, "LOFAR_FILE_TYPE");
+ roFileDate_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ roObservationStartQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ roObservationEndQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ roObservationFrequencyMaxQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ roObservationFrequencyMinQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ roObservationFrequencyCenterQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ roClockFrequencyQuant_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ roFileDateQuant_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ roObservationStartMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ roObservationEndMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ roFileDateMeas_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ // Read/write
+ rwProjectTitle_p.attach (msLofarObservation, "LOFAR_PROJECT_TITLE");
+ rwProjectPI_p.attach (msLofarObservation, "LOFAR_PROJECT_PI");
+ rwProjectCoI_p.attach (msLofarObservation, "LOFAR_PROJECT_CO_I");
+ rwProjectContact_p.attach (msLofarObservation, "LOFAR_PROJECT_CONTACT");
+ rwObservationId_p.attach (msLofarObservation, "LOFAR_OBSERVATION_ID");
+ rwObservationStart_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ rwObservationEnd_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ rwObservationFrequencyMax_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ rwObservationFrequencyMin_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ rwObservationFrequencyCenter_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ rwSubArrayPointing_p.attach (msLofarObservation, "LOFAR_SUB_ARRAY_POINTING");
+ rwAntennaSet_p.attach (msLofarObservation, "LOFAR_ANTENNA_SET");
+ rwFilterSelection_p.attach (msLofarObservation, "LOFAR_FILTER_SELECTION");
+ rwClockFrequency_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ rwTarget_p.attach (msLofarObservation, "LOFAR_TAGET");
+ rwSystemVersion_p.attach (msLofarObservation, "LOFAR_SYSTEM_VERSION");
+ rwPipelineName_p.attach (msLofarObservation, "LOFAR_PIPELINE_NAME");
+ rwPipelineVersion_p.attach (msLofarObservation, "LOFAR_PIPELINE_VERSION");
+ rwFileName_p.attach (msLofarObservation, "LOFAR_FILE_NAME");
+ rwFileType_p.attach (msLofarObservation, "LOFAR_FILE_TYPE");
+ rwFileDate_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ rwObservationStartQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ rwObservationEndQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ rwObservationFrequencyMaxQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MAX");
+ rwObservationFrequencyMinQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_MIN");
+ rwObservationFrequencyCenterQuant_p.attach (msLofarObservation, "LOFAR_OBSERVATION_FREQUENCY_CENTER");
+ rwClockFrequencyQuant_p.attach (msLofarObservation, "LOFAR_CLOCK_FREQUENCY");
+ rwFileDateQuant_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ rwObservationStartMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_START");
+ rwObservationEndMeas_p.attach (msLofarObservation, "LOFAR_OBSERVATION_END");
+ rwFileDateMeas_p.attach (msLofarObservation, "LOFAR_FILE_DATE");
+ }
+
+} //# end namespace
diff --git a/LCS/MSLofar/src/MSLofarObservation.cc b/LCS/MSLofar/src/MSLofarObservation.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f353fb54cfba76b56c8d6a3b04a1c4df34a1e6e1
--- /dev/null
+++ b/LCS/MSLofar/src/MSLofarObservation.cc
@@ -0,0 +1,117 @@
+//# MSLofarObservation.cc: MS OBSERVATION subtable with LOFAR extensions
+//# Copyright (C) 2011
+//# ASTRON (Netherlands Institute for Radio Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands
+//#
+//# This file is part of the LOFAR software suite.
+//# The LOFAR software suite is free software: you can redistribute it and/or
+//# modify it under the terms of the GNU General Public License as published
+//# by the Free Software Foundation, either version 3 of the License, or
+//# (at your option) any later version.
+//#
+//# The LOFAR software suite is distributed in the hope that it will be useful,
+//# but WITHOUT ANY WARRANTY; without even the implied warranty of
+//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+//# GNU General Public License for more details.
+//#
+//# You should have received a copy of the GNU General Public License along
+//# with the LOFAR software suite. If not, see <http://www.gnu.org/licenses/>.
+//#
+//# $Id$
+//#
+//# @author Ger van Diepen
+
+#include <lofar_config.h>
+#include <MSLofar/MSLofarObservation.h>
+#include <measures/Measures/MEPoch.h>
+
+using namespace casa;
+
+namespace LOFAR {
+
+ MSLofarObservation::MSLofarObservation()
+ {}
+
+ MSLofarObservation::MSLofarObservation (const String& tableName,
+ Table::TableOption option)
+ : MSObservation (tableName, option)
+ {}
+
+ MSLofarObservation::MSLofarObservation (SetupNewTable& newTab, uInt nrrow,
+ Bool initialize)
+ : MSObservation (newTab, nrrow, initialize)
+ {}
+
+ MSLofarObservation::MSLofarObservation (const Table& table)
+ : MSObservation (table)
+ {}
+
+ MSLofarObservation::MSLofarObservation (const MSLofarObservation& that)
+ : MSObservation (that)
+ {}
+
+ MSLofarObservation::~MSLofarObservation()
+ {}
+
+ MSLofarObservation& MSLofarObservation::operator= (const MSLofarObservation& that)
+ {
+ MSObservation::operator= (that);
+ return *this;
+ }
+
+ TableDesc MSLofarObservation::requiredTableDesc()
+ {
+ TableDesc td (MSObservation::requiredTableDesc());
+ MSLofarTable::addColumn (td, "LOFAR_PROJECT_TITLE", TpString,
+ "Project description");
+ MSLofarTable::addColumn (td, "LOFAR_PROJECT_PI", TpString,
+ "Principal investigator");
+ MSLofarTable::addColumn (td, "LOFAR_PROJECT_CO_I", TpArrayString,
+ "Co investigators");
+ MSLofarTable::addColumn (td, "LOFAR_PROJECT_CONTACT", TpString,
+ "Contact author");
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_ID", TpString,
+ "Observation ID");
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_START", TpDouble,
+ "Observation start",
+ "s", "EPOCH", MEpoch::UTC);
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_END", TpDouble,
+ "Observation end",
+ "s", "EPOCH", MEpoch::UTC);
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_FREQUENCY_MAX", TpDouble,
+ "Maximum frequency",
+ "MHz");
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_FREQUENCY_MIN", TpDouble,
+ "Minimum frequency",
+ "MHz");
+ MSLofarTable::addColumn (td, "LOFAR_OBSERVATION_FREQUENCY_CENTER", TpDouble,
+ "Center frequency",
+ "MHz");
+ MSLofarTable::addColumn (td, "LOFAR_SUB_ARRAY_POINTING", TpInt,
+ "Subarray pointing id");
+ MSLofarTable::addColumn (td, "LOFAR_ANTENNA_SET", TpString,
+ "SAS Antenna set name");
+ MSLofarTable::addColumn (td, "LOFAR_FILTER_SELECTION", TpString,
+ "SAS Filter selection");
+ MSLofarTable::addColumn (td, "LOFAR_CLOCK_FREQUENCY", TpDouble,
+ "SAS Clock setting",
+ "MHz");
+ MSLofarTable::addColumn (td, "LOFAR_TARGET", TpArrayString,
+ "List of targets");
+ MSLofarTable::addColumn (td, "LOFAR_SYSTEM_VERSION", TpString,
+ "Version of the system");
+ MSLofarTable::addColumn (td, "LOFAR_PIPELINE_NAME", TpString,
+ "Pipeline identification");
+ MSLofarTable::addColumn (td, "LOFAR_PIPELINE_VERSION", TpString,
+ "Pipeline version");
+ MSLofarTable::addColumn (td, "LOFAR_FILE_NAME", TpString,
+ "Name of raw data set");
+ MSLofarTable::addColumn (td, "LOFAR_FILE_TYPE", TpString,
+ "Data type (uv)");
+ MSLofarTable::addColumn (td, "LOFAR_FILE_DATE", TpDouble,
+ "File creation time",
+ "s", "EPOCH", MEpoch::UTC);
+ return td;
+ }
+
+} //# end namespace