Added documentation,

removed old utilities,
added docs/utilities.txt with a description of the utilities
Renamed the memory elements to have more sensible names


git-svn-id: svn+ssh://jop91.astron.nl/auto/home/jive_cvs/SOFTC/svn/trunk/sfxc@789 5736e3ea-d426-0410-8aaf-93e336ac3372

Author: kruithof

docs/utilities.txt

@@ -0,0 +1,108 @@
+produce_html_plotpage
+---------------------
+Usage: produce_html_plotpage [-f] <vex-file> \
+          <correlation_file> [<output_directory>]
+          
+Generates the html-pages used for the ftp-fringe tests. 
+
+Options:
+  -f With this option produce_html_plotpage doesn't after generating the 
+     html-page continues reading in new integration slices and plots those.
+
+
+produce_html_diffpage
+---------------------
+Usage: produce_html_diffpage <vex-file> \
+          <correlation_file1> <correlation_file2> [<output_directory>]
+
+Shows the difference between two correlation output files. 
+Very similar to produce_html_plotpage
+
+vex2ccf
+-------
+Generates a skeleton for a ctrl-file from a vex file
+Usage: vex2ccf [--full|-f] [--das3] <vex-file> <ctrl-file>
+
+Options:
+  --full, -f: generate more information, that can be used by the work flow
+              manager
+  --das3:     addes a das3 specific section
+
+
+baseline_info
+-------------
+Prints out information about all integrations of one baseline
+Usage: baseline_info <cor-file> <ch_nr> <sideband> <st_nr1> <pol1> <st_nr2> <pol2>
+
+All arguments, except for the cor-file, are the values as found in the
+  baseline-header
+  
+The output is a table with a row for every integration containing:
+  - The location of the fringe
+  - The phase of the fringe
+  - The absolute value of the fringe
+  - The phase of the center lag
+  - The absolute value of the center lag
+  - The signal to noise ratio
+  - the weight
+
+
+phase_plot
+----------
+Usage: phase_plot <cor-file>
+Writes out the phase of the fringe for every timeslice
+Each row contains the phases for every baseline, in the order that they occur 
+in the correlation file
+
+plot_delay_table
+----------------
+converts a binary delay table to an interpolated ascii table
+Usage: plot_delay_table <delay-table> <plot-file>
+
+each row contains a value for the time and the delay. 
+Scans are separated with an extra newline, which makes gnuplot draw a new curve.
+
+mark5a_print_headers
+--------------------
+Prints the timestamps in the headers of a mark5a file
+Usage: mark5a_print_headers <mark5a-file>
+
+print_new_output_format
+-----------------------
+Usage: print_new_output_format <cor-file>
+
+Prints out all headers in the output correlation file to std::cout and 
+writes the data to the file "output_new.txt".
+
+
+generate_uvw_coordinates
+------------------------
+Usage: generate_uvw_coordinates <delay-file> <start> <stop> <integration-time> <output-file>
+
+Generates a file with ascii uvw coordinates from a delay file
+
+make_anim
+---------
+Usage: make_anim <ctrl-file> <station1_nr> <station2_nr>
+
+Makes an animated gif displaying the evolution of the fringe of a certain
+baseline over time
+
+  
+dnfp_fileclient
+---------------
+A utility made by Damien to transfer data from a dnfp_server 
+
+This file contains a little file client based on a simple protocol. 
+The application simply connect to a dnfp server and request a file.
+
+dnfp_fileserver
+---------------
+A utility made by Damien to serve data over a network
+
+This file contains a little file server based on a simple protocol. 
+The application use a config file named: dnfp_configfile.cfg
+
+this file stores the list of file to expose to the clients...and there 
+symbolic name in the format:
+name1 /path/to/real/file

include/correlation_core.h

@@ -11,10 +11,13 @@
 
 class Correlation_core : public Tasklet {
 public:
-  typedef Delay_correction::Output_buffer_element        Input_buffer_element;
-  typedef Delay_correction::Output_buffer                Input_buffer;
-  typedef Delay_correction::Output_buffer_ptr            Input_buffer_ptr;
+  typedef Delay_correction::Output_buffer_element          Input_buffer_element;
+  typedef Delay_correction::Output_buffer                  Input_buffer;
+  typedef Delay_correction::Output_buffer_ptr              Input_buffer_ptr;
 
+  typedef Memory_pool_vector_element<FLOAT>                Float_buffer;
+  typedef Memory_pool_vector_element<std::complex<FLOAT> > Complex_buffer;
+  typedef Memory_pool_vector_element<std::complex<float> > Complex_buffer_float;
   Correlation_core();
   virtual ~Correlation_core();
 
@@ -69,22 +72,22 @@ class Correlation_core : public Tasklet {
 
   int number_ffts_in_integration, current_fft, total_ffts;
 
-  FFTW_PLAN                             plan;
-  Aligned_vector<FLOAT>                 plan_input_buffer;
-  Aligned_vector<std::complex<FLOAT> >  plan_output_buffer;
+  FFTW_PLAN       plan;
+  Float_buffer    plan_input_buffer;
+  Complex_buffer  plan_output_buffer;
 
   //std::vector< FLOAT >               plan_input_buffer;
   //std::vector< std::complex<FLOAT> > plan_output_buffer;
 
 
-  Correlation_parameters                            correlation_parameters;
+  Correlation_parameters                               correlation_parameters;
 
-  std::vector< Aligned_vector< std::complex<FLOAT> > > frequency_buffer;
-  std::vector< std::vector<std::complex<FLOAT> > >     accumulation_buffers;
-  std::vector< std::complex<float> >                   accumulation_buffers_float;
+  std::vector< Complex_buffer >                        frequency_buffer;
+  std::vector< Complex_buffer >                        accumulation_buffers;
+  Complex_buffer_float                                 accumulation_buffers_float;
   std::vector< std::pair<size_t, size_t> >             baselines;
 
-  boost::shared_ptr<Data_writer>                    writer;
+  boost::shared_ptr<Data_writer>                       writer;
 
   Timer fft_timer;
 
@@ -94,9 +97,9 @@ class Correlation_core : public Tasklet {
 
 #ifdef SFXC_WRITE_STATS
   // For plotting statistics on the height of the fringe and the phase
-  std::ofstream stats_out;
-  Aligned_vector<std::complex<FLOAT> >  backward_buffer;
-  FFTW_PLAN backward_plan_;
+  std::ofstream                                        stats_out;
+  Complex_buffer                                       backward_buffer;
+  FFTW_PLAN                                            backward_plan_;
 #endif // SFXC_WRITE_STATS
 
 };

include/correlator_node.h

@@ -52,7 +52,7 @@ class Correlator_node_controller : public Controller {
 class Correlator_node : public Node {
 public:
   typedef Correlator_node                              Self;
-  typedef Buffer_element_vector<char>                  output_value_type;
+  typedef Memory_pool_vector_element<char>             output_value_type;
 
 
 private:

include/correlator_node_types.h

@@ -48,7 +48,7 @@ class Correlator_node_types {
   typedef Threadsafe_queue<Bit_sample_memory_pool_element> Bit_sample_queue;
   typedef boost::shared_ptr<Bit_sample_queue>              Bit_sample_queue_ptr;
 
-  typedef Aligned_vector<FLOAT>                            Float_element;
+  typedef Memory_pool_vector_element<FLOAT>                Float_element;
   typedef Memory_pool<Float_element>                       Float_memory_pool;
   typedef Threadsafe_queue<Float_memory_pool::Element>     Float_queue;
   typedef boost::shared_ptr<Float_queue>                   Float_queue_ptr;

include/delay_correction.h

@@ -65,7 +65,7 @@ class Delay_correction : public Tasklet {
 
 private:
   // access functions to the correlation parameters
-  int number_channels();
+  size_t number_channels();
   int sample_rate();
   int bandwidth();
   int length_of_one_fft(); // Length of one fft in microseconds
@@ -91,7 +91,7 @@ class Delay_correction : public Tasklet {
   Delay_table_akima   delay_table;
 
   // You need this one because the input and output are FLOATs (not complex)
-  Aligned_vector< std::complex<FLOAT> > frequency_buffer;
+  Memory_pool_vector_element< std::complex<FLOAT> > frequency_buffer;
 
   Timer delay_timer;
 

include/manager_node.h

@@ -30,6 +30,10 @@ class Manager_node_controller : public Controller {
 };
 
 
+/**
+ * The manager node 
+ * \ingroup Node
+ **/
 class Manager_node : public Abstract_manager_node {
 public:
   enum Status {

include/memory_pool_elements.h

@@ -20,87 +20,22 @@
 
 #include "utils.h"
 
-/// Use this element for the buffer class if you want to store an array
-/// on every position.
-///// DEPRECATED SHOULD BE REMOVED...
-template <class T, int N>
-class Buffer_element {
-public:
-  typedef T value_type;
-  inline int size() {
-    return N;
-  }
-
-  T &operator[](int i) {
-    assert(i >= 0);
-    assert(i < N);
-    return _buffer[i];
-  }
-  T *buffer() {
-    return &_buffer[0];
-  }
-private:
-  T _buffer[N];
-};
-
-/// Use this class if you want to allocate large number of element
-/// static array declaration may fails if the array is too large...
-template <class T, int N>
-class Buffer_element_large {
-public:
-  typedef T value_type;
-  inline int size() {
-    return N;
-  }
-
-  Buffer_element_large() {
-    //std::cout << "Building array of size" << N << std::endl;
-    _buffer = static_cast<T*>(fftw_malloc(sizeof(T)*N));
-  }
-
-  Buffer_element_large(const Buffer_element_large& src) {
-    //std::cout << "Building by copy an array of size" << N << std::endl;
-    _buffer = static_cast<T*>(fftw_malloc(sizeof(T)*N));
-    memcpy(_buffer, src._buffer, sizeof(T)*N );
-  }
-
-  ~Buffer_element_large() {
-    //std::cout << "Deleting array of size" << N << std::endl;
-    if (_buffer != NULL) {
-      fftw_free(_buffer);
-    }
-  }
-
-  inline T &operator[](int i) {
-    assert(i >= 0);
-    assert(i < N);
-    return (_buffer)[i];
-  }
-
-  inline T *buffer() {
-    return _buffer;
-  }
-private:
-
-  T* _buffer;
-};
-
 /// Use this class if you want to allocate large number of element
 /// static array declaration may fail if the array is too large...
 template <class T>
-class Aligned_vector {
+class Memory_pool_vector_element {
 public:
   typedef T value_type;
   inline size_t size() const {
     return size_;
   }
 
-  Aligned_vector() {
+  Memory_pool_vector_element() {
     size_ = 0;
     buffer_ = NULL;
   }
 
-  ~Aligned_vector() {
+  ~Memory_pool_vector_element() {
     // DEBUG_MSG("Deleting array element of size " << size());
     if (buffer_ != NULL) {
       fftw_free(buffer_);
@@ -151,10 +86,46 @@ class Aligned_vector {
   size_t size_;
 };
 
-template<class T>
-class Buffer_element_vector : public Aligned_vector<T> {
+/// Use this class if you want to allocate large number of element
+/// static array declaration may fail if the array is too large...
+template <class T, int N>
+class Memory_pool_fixed_size_element {
 public:
   typedef T value_type;
+  inline size_t size() const {
+    return N;
+  }
+
+  Memory_pool_fixed_size_element() {
+    // fftw_malloc insure that the allocated data
+    // is nicely aligned.
+    buffer_ = static_cast<T*>( fftw_malloc(sizeof(T)*N) );
+  }
+
+  ~Memory_pool_fixed_size_element() {
+    fftw_free(buffer_);
+  }
+
+  inline T& operator[](int i) {
+    assert(i >= 0);
+    assert(i < N );
+    return buffer_[i];
+  }
+
+  inline const T& operator[](int i) const {
+    assert(i >= 0);
+    assert(i < N );
+    return buffer_[i];
+  }
+
+  inline T* buffer() {
+    return buffer_;
+  }
+private:
+
+  // We cannot use a std::vector because we cannot control that
+  // the data are properly aligned to be used with fftw_xx or SSE
+  T* buffer_;
 };
 
 #endif // BUFFER_H

include/multiple_data_readers_controller.h

@@ -24,7 +24,7 @@
 class Multiple_data_readers_controller : public Controller {
   typedef Multiple_data_readers_controller  Self;
 public:
-  typedef Buffer_element_large<char,5000>            data_type;
+  typedef Memory_pool_fixed_size_element<char,5000>  data_type;
   typedef Data_reader2buffer<data_type>              Reader2buffer;
   typedef Data_reader_buffer<data_type>              Reader_buffer;
 

include/multiple_data_writers_controller.h

@@ -23,9 +23,9 @@
 class Multiple_data_writers_controller : public Controller {
   typedef Multiple_data_writers_controller  Self;
 public:
-  typedef Buffer_element<char,131072>                data_type;
-  typedef Memory_pool<data_type>                     Memory_pool;
-  typedef Memory_pool::value_type                    pool_type;
+  typedef Memory_pool_vector_element<char>             data_type;
+  typedef Memory_pool<data_type>                       Memory_pool;
+  typedef Memory_pool::value_type                      pool_type;
   struct value_type {
     int       actual_size;
     pool_type data;

include/single_data_reader_controller.h

@@ -22,12 +22,9 @@
 class Single_data_reader_controller : public Controller {
   typedef Single_data_reader_controller  Self;
 public:
-  typedef Buffer_element_large<char,256>             data_type;
+  typedef Memory_pool_fixed_size_element<char,256>   data_type;
   typedef Data_reader2buffer<data_type>              Reader2buffer;
-
-  typedef Reader2buffer::Memory_pool                 Memory_pool;
   typedef Reader2buffer::value_type                  value_type;
-  typedef Reader2buffer::Queue                       Queue;
   typedef Reader2buffer::Queue_ptr                   Queue_ptr;
 
   Single_data_reader_controller(Node &node);