%[ER: 146]%

Renamed from DH_In/utDFT

CEP/BB/PSS3/src/files/DH_DFTRequest.cc

+//  DH_DFTRequest.cc:
+//
+//  Copyright (C) 2004
+//  ASTRON (Netherlands Foundation for Research in Astronomy)
+//  P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//
+//  This program 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 2 of the License, or
+//  (at your option) any later version.
+//
+//  This program 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 this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+//  $Id$
+
+
+#include <PSS3/DH_DFTRequest.h>
+#include <Common/LofarLogger.h>
+
+namespace LOFAR
+{
+
+DH_DFTRequest::DH_DFTRequest()
+: DataHolder ("", "DH_DFTRequest"),
+  itsUVW     (0)
+{}
+
+DH_DFTRequest::DH_DFTRequest(const DH_DFTRequest& that)
+: DataHolder (that),
+  itsUVW     (0)
+{}
+
+DH_DFTRequest::~DH_DFTRequest()
+{}
+
+DataHolder* DH_DFTRequest::clone() const
+{
+  return new DH_DFTRequest(*this);
+}
+
+void DH_DFTRequest::preprocess()
+{
+  // Add the fields to the data definition.
+  // The dimensionality of UVW is variable.
+  // Its axes are ntime and nantenna.
+  addField ("UVW", BlobField<double>(1, 0u, 0u));
+  addField ("StartFreq", BlobField<double>(1));
+  addField ("StepFreq", BlobField<double>(1));
+  addField ("NFreq", BlobField<int32>(1));
+  addField ("NTime", BlobField<int32>(1));
+  addField ("StartTime", BlobField<double>(1));
+  addField ("StepTime", BlobField<double>(1));
+  addField ("L", BlobField<double>(1));
+  addField ("M", BlobField<double>(1));
+  addField ("N", BlobField<double>(1));
+  // The Ant nrs tell the antenna pairs froming the baselines.
+  addField ("Ant1", BlobField<int32> (1, 0u));
+  addField ("Ant2", BlobField<int32> (1, 0u));
+}
+
+void DH_DFTRequest::set (double startFreq, double stepFreq, int nFreq,
+		    double startTime, double stepTime, int nTime,
+		    int nAnt, int nBaseline)
+{
+  std::vector<uint32> shape(2);
+  shape[0] = nTime;
+  shape[1] = nAnt;
+  getDataField("UVW").setShape (shape);
+  getDataField("Ant").setShape (std::vector<uint32>(1,nAnt));
+  getDataField("Ant1").setShape (std::vector<uint32>(1,nBaseline));
+  getDataField("Ant2").setShape (std::vector<uint32>(1,nBaseline));
+  // Create the data blob (which calls fillDataPointers).
+  createDataBlock();
+  *itsStartFreq = startFreq;
+  *itsStepFreq  = stepFreq;
+  *itsNFreq     = nFreq;
+  *itsStartTime = startTime;
+  *itsStepTime  = stepTime;
+  *itsNTime     = nTime;
+}
+
+void DH_DFTRequest::fillDataPointers()
+{
+  // Fill in the data pointers.
+  itsUVW = getData<double> ("UVW");
+  itsNFreq     = getData<uint32> ("NFreq");
+  itsStartFreq = getData<double> ("StartFreq");
+  itsStepFreq  = getData<double> ("StepFreq");
+  itsStartTime = getData<double> ("StartTime");
+  itsStepTime  = getData<double> ("StepTime");
+  itsNTime     = getData<uint32> ("NTime");
+  itsL         = getData<double> ("L");
+  itsM         = getData<double> ("M");
+  itsN         = getData<double> ("N");
+  itsAnt       = getData<int32>  ("Ant");
+  itsNAnt      = getDataField("Ant").getNelem();
+  itsAnt1      = getData<int32>  ("Ant1");
+  itsAnt2      = getData<int32>  ("Ant2");
+  itsNBaseline = getDataField("Ant1").getNelem();
+  ASSERT (itsNBaseline == getDataField("Ant2").getNelem());
+  const std::vector<uint32>& shape = getDataField("UVW").getShape();
+  ASSERT (shape.size() == 2);
+  ASSERT (*itsNTime == shape[0]);
+  ASSERT (itsNAnt == shape[1]);
+}
+
+
+void DH_DFTRequest::postprocess()
+{
+  itsUVW = 0;
+}
+
+} // end namespace

CEP/BB/PSS3/src/files/DH_DFTRequest.h

+//# DH_DFTRequest.h: Input DataHolder for the DFT
+//#
+//# Copyright (C) 2004
+//# ASTRON (Netherlands Foundation for Research in Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//#
+//# This program 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 2 of the License, or
+//# (at your option) any later version.
+//#
+//# This program 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 this program; if not, write to the Free Software
+//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//#
+//# $Id$
+
+#ifndef BB_DH_INDFT_H
+#define BB_DH_INDFT_H
+
+
+#include <Common/LofarTypes.h>
+#include <Transport/DataHolder.h>
+
+namespace LOFAR
+{
+
+
+class DH_DFTRequest: public DataHolder
+{
+public:
+  explicit DH_DFTRequest();
+
+  DH_DFTRequest(const DH_DFTRequest&);
+
+  virtual ~DH_DFTRequest();
+
+  DataHolder* clone() const;
+
+  /// Allocate the buffers.
+  virtual void preprocess();
+
+  /// Deallocate the buffers.
+  virtual void postprocess();
+
+  /// Get read access to the various data fields.
+  // <group>
+  const double* getUVW() const;
+  double getStartFreq() const;
+  double getStepFreq() const;
+  int    getNFreq() const;
+  double getStartTime() const;
+  double getStepTime() const;
+  int    getNTime() const;
+  double getL() const;
+  double getM() const;
+  double getN() const;
+  const int32* getAnt() const;
+  int    getNAnt() const;
+  const int32* getAnt1() const;
+  const int32* getAnt2() const;
+  int    getNBaseline() const;
+  // </group>
+
+  // Set the values of various fields.
+  // It will create the data block.
+  void set (double startFreq, double stepFreq, int nFreq,
+	    double startTime, double stepTime, int nTime,
+	    int nAnt, int nBaseline);
+  /// Give write access to the variable sized data fields.
+  // The set function should have been called before.
+  // <group>
+  double* accessUVW();
+  int32*  accessAnt();
+  int32*  accessAnt1();
+  int32*  accessAnt2();
+  // </group>
+
+private:
+  /// Forbid assignment.
+  DH_DFTRequest& operator= (const DH_DFTRequest&);
+
+  // Fill the pointers to the data in the blob.
+  virtual void fillDataPointers();
+
+
+  double* itsUVW;
+  double* itsStartFreq;
+  double* itsStepFreq;
+  uint32* itsNFreq;
+  double* itsStartTime;
+  double* itsStepTime;
+  uint32* itsNTime;
+  double* itsL;
+  double* itsM;
+  double* itsN;
+  int32*  itsAnt;
+  uint32  itsNAnt;
+  int32*  itsAnt1;
+  int32*  itsAnt2;
+  uint32  itsNBaseline;
+};
+
+
+inline const double* DH_DFTRequest::getUVW() const
+  { return itsUVW; }
+
+inline double DH_DFTRequest::getStartFreq() const
+  { return *itsStartFreq; }
+inline double DH_DFTRequest::getStepFreq() const
+  { return *itsStepFreq; }
+inline int DH_DFTRequest::getNFreq() const
+  { return *itsNFreq; }
+
+inline double DH_DFTRequest::getStartTime() const
+  { return *itsStartTime; }
+inline double DH_DFTRequest::getStepTime() const
+  { return *itsStepTime; }
+inline int DH_DFTRequest::getNTime() const
+  { return *itsNTime; }
+
+inline double DH_DFTRequest::getL() const
+  { return *itsL; }
+inline double DH_DFTRequest::getM() const
+  { return *itsM; }
+inline double DH_DFTRequest::getN() const
+  { return *itsN; }
+
+inline const int32* DH_DFTRequest::getAnt() const
+  { return itsAnt; }
+inline int DH_DFTRequest::getNAnt() const
+  { return itsNAnt; }
+
+inline const int32* DH_DFTRequest::getAnt1() const
+  { return itsAnt1; }
+inline const int32* DH_DFTRequest::getAnt2() const
+  { return itsAnt2; }
+inline int DH_DFTRequest::getNBaseline() const
+  { return itsNBaseline; }
+
+inline double* DH_DFTRequest::accessUVW()
+  { return itsUVW; }
+inline int32* DH_DFTRequest::accessAnt()
+  { return itsAnt; }
+inline int32* DH_DFTRequest::accessAnt1()
+  { return itsAnt1; }
+inline int32* DH_DFTRequest::accessAnt2()
+  { return itsAnt2; }
+
+   
+}
+
+#endif 
+   

CEP/BB/PSS3/src/files/DH_DFTResult.cc

+//  DH_DFTResult.cc:
+//
+//  Copyright (C) 2004
+//  ASTRON (Netherlands Foundation for Research in Astronomy)
+//  P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//
+//  This program 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 2 of the License, or
+//  (at your option) any later version.
+//
+//  This program 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 this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+//  $Id$
+
+
+#include <PSS3/DH_DFTResult.h>
+#include <Common/LofarLogger.h>
+
+namespace LOFAR
+{
+
+DH_DFTResult::DH_DFTResult()
+: DataHolder ("", "DH_DFTResult"),
+  itsValues  (0)
+{}
+
+DH_DFTResult::DH_DFTResult(const DH_DFTResult& that)
+: DataHolder (that),
+  itsValues  (0)
+{}
+
+DH_DFTResult::~DH_DFTResult()
+{}
+
+DataHolder* DH_DFTResult::clone() const
+{
+  return new DH_DFTResult(*this);
+}
+
+void DH_DFTResult::preprocess()
+{
+  // Add the fields to the data definition.
+  // The dimensionality of Data is variable.
+  // Its axes are nfreq,ntime,nbaseline.
+  // Its data is complex<double> represented by 2 doubles.
+  addField ("Values", BlobField<double>(1, 0u, 0u, 0u, 2u));
+}
+
+void DH_DFTResult::set (int nFreq, int nTime, int nBaseline)
+{
+  std::vector<uint32> shape(4);
+  shape[0] = nFreq;
+  shape[1] = nTime;
+  shape[2] = nBaseline;
+  shape[3] = 2;
+  getDataField("Values").setShape (shape);
+  // Create the data blob (which calls fillDataPointers).
+  createDataBlock();
+}
+
+void DH_DFTResult::fillDataPointers()
+{
+  // Fill in the data pointer.
+  itsValues = getData<double> ("Values");
+  const std::vector<uint32>& shape = getDataField("Values").getShape();
+  ASSERT (shape.size() == 4);
+  itsNFreq = shape[0];
+  itsNTime = shape[1];
+  itsNBaseline = shape[2];
+  ASSERT (shape[3] == 2);
+}
+
+
+void DH_DFTResult::postprocess()
+{
+  itsValues = 0;
+}
+
+} // end namespace

CEP/BB/PSS3/src/files/DH_DFTResult.h

+//# DH_DFTResult.h: Output DataHolder for the DFT
+//#
+//# Copyright (C) 2004
+//# ASTRON (Netherlands Foundation for Research in Astronomy)
+//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
+//#
+//# This program 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 2 of the License, or
+//# (at your option) any later version.
+//#
+//# This program 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 this program; if not, write to the Free Software
+//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//#
+//# $Id$
+
+#ifndef BB_DH_OUTDFT_H
+#define BB_DH_OUTDFT_H
+
+
+#include <Common/LofarTypes.h>
+#include <Transport/DataHolder.h>
+
+namespace LOFAR
+{
+
+
+class DH_DFTResult: public DataHolder
+{
+public:
+  explicit DH_DFTResult();
+
+  DH_DFTResult(const DH_DFTResult&);
+
+  virtual ~DH_DFTResult();
+
+  DataHolder* clone() const;
+
+  /// Allocate the buffers.
+  virtual void preprocess();
+
+  /// Deallocate the buffers.
+  virtual void postprocess();
+
+  /// Get read access to the various data fields.
+  // The data is a double complex, but it is handled as 2 doubles.
+  // <group>
+  const double* getValues() const;
+  int getNFreq() const;
+  int getNTime() const;
+  int getNBaseline() const;
+  // </group>
+
+  // Set the size of the data fields.
+  // It will create the data block.
+  void set (int nFreq, int nTime, int nBaseline);
+
+  /// Give write access to the variable sized.
+  // The set function should have been called before.
+  // <group>
+  double* accessValues();
+
+  /// Forbid assignment.
+  DH_DFTResult& operator= (const DH_DFTResult&);
+
+  // Fill the pointers to the data in the blob.
+  virtual void fillDataPointers();
+
+
+  double* itsValues;
+  uint32  itsNTime;
+  uint32  itsNFreq;
+  uint32  itsNBaseline;
+};
+
+
+inline const double* DH_DFTResult::getValues() const
+  { return itsValues; }
+inline int DH_DFTResult::getNFreq() const
+  { return itsNFreq; }
+inline int DH_DFTResult::getNTime() const
+  { return itsNTime; }
+inline int DH_DFTResult::getNBaseline() const
+  { return itsNBaseline; }
+
+inline double* DH_DFTResult::accessValues()
+  { return itsValues; }
+
+   
+}
+
+#endif 
+