Renamed m1/m2 params to mass1/mass2 for compatibility with LIGOLW XML.
authorTito Dal Canton <tito.canton@ligo.org>
Mon, 14 Jan 2013 17:38:53 +0000 (18:38 +0100)
committerTito Dal Canton <tito.canton@ligo.org>
Mon, 14 Jan 2013 17:38:53 +0000 (18:38 +0100)
Fixed reading template banks from LIGOLW XML.
Generalized MetaIO::read_approximant() to MetaIO::read_option_value().
Added chi-squared timer to findchirp application.
Minor fixes in a couple places.

17 files changed:
cbc/benchmark/src/benchmark.cpp
cbc/duration/include/duration-cli.hpp
cbc/duration/src/duration-cli.cpp
cbc/duration/src/duration.cpp
cbc/findchirp/mytemplatebank.txt
cbc/findchirp/src/findchirp.cpp
cbc/templatebank/src/templatebank.cpp
cbc/waveform/include/waveform-cli.hpp
cbc/waveform/src/waveform-cli.cpp
cbc/waveform/src/waveform.cpp
common/include/io/GWMetaIO.hpp
common/include/templatebank/GWTemplateBank.hpp
common/include/waveform/GWWaveformBase.hpp
common/include/waveform/GWWaveformTaylorF2.hpp
common/src/GWClusterSimpleMax.cl
common/src/io/GWMetaIO.cpp
common/unittest/io/metaio_unittest.cpp

index 0b960fc..d0e96ad 100644 (file)
@@ -107,8 +107,8 @@ int main(int ac, char* av[]) {
     m1 = 1.4;
     m2 = 1.4;
     flow = 10.0;
-    myIntParams["m1"] =  m1;
-    myIntParams["m2"] =  m2;
+    myIntParams["mass1"] =  m1;
+    myIntParams["mass2"] =  m2;
     myIntParams["flow"] = flow;
 
     GW::FrequencySeries <cFloat> * src = new GW::FrequencySeries <cFloat>(
index 91f18a0..b337a1d 100644 (file)
@@ -34,8 +34,8 @@ namespace GW {
 
     CLIDuration(int ac, char* av[]);
 
-    float get_m1()   const {return m_var_map["m1"].as<float>();}
-    float get_m2()   const {return m_var_map["m2"].as<float>();}
+    float get_m1()   const {return m_var_map["mass1"].as<float>();}
+    float get_m2()   const {return m_var_map["mass2"].as<float>();}
     float get_flow() const {return m_var_map["flow"].as<float>();}
 
   };
index a7d7054..4e1906e 100644 (file)
@@ -20,8 +20,8 @@ GW::CLIDuration::CLIDuration(int ac, char* av[]) :
   CLIBase()
 {
   m_opt_desc.add_options()
-    ("m1",   po::value<float>()->default_value(0), "the mass of the first object in solar mass units")
-    ("m2",   po::value<float>()->default_value(0), "the mass of the second object in solar mass units")
+    ("mass1",   po::value<float>()->default_value(0), "the mass of the first object in solar mass units")
+    ("mass2",   po::value<float>()->default_value(0), "the mass of the second object in solar mass units")
     ("flow", po::value<float>()->default_value(0), "starting frequency")
     ;
 
index e66a4d3..de29458 100644 (file)
@@ -41,8 +41,8 @@ int main(int ac, char* av[]) {
     GW::ExtrinsicWaveformParameters  myExtParams;
 
     // Setting the parameters
-    myIntParams["m1"]   = myCli.get_m1();
-    myIntParams["m2"]   = myCli.get_m2();
+    myIntParams["mass1"]   = myCli.get_m1();
+    myIntParams["mass2"]   = myCli.get_m2();
     myIntParams["flow"] = myCli.get_flow();
 
     // Calculating the duration
index bfef471..9cf4cec 100644 (file)
@@ -2,7 +2,7 @@
 ## You can write anything to here
 @Waveform: TaylorF2
 @Flow: 40.0
-@Parameters: m1 m2
+@Parameters: mass1 mass2
 5.4 8.1
 9.4 8.1
 7.4 6.1
index 2eb15be..6c894d7 100644 (file)
@@ -99,8 +99,17 @@ int main(int ac, char* av[]) {
        GW::ClusteringParameters            cluster_args;
 
     // Some timer index for the benchmarking
-    enum timers {t_total = 0, t_precond = 1, t_generate = 2, t_variance = 3,
-                 t_copy=4, t_cluster=5, t_filter=6, t_norm = 7};
+    enum timers {
+        t_total = 0,
+        t_precond = 1,
+        t_generate = 2,
+        t_variance = 3,
+        t_copy =4,
+        t_cluster = 5,
+        t_filter = 6,
+        t_norm = 7,
+        t_chisq = 8
+    };
 
     myTimer.Start(t_total);
     myTimer.Start(t_precond);
@@ -155,7 +164,7 @@ int main(int ac, char* av[]) {
     *chi2 = 0;
 
     // Reading in the template bank
-       myTemplateBank.Read(template_bank_file);
+    myTemplateBank.Read(template_bank_file);
 
     // Determining the longest template in the template bank
        myTemplateBank.GetLongestTemplate(longest_template_length,
@@ -279,8 +288,10 @@ int main(int ac, char* av[]) {
 
             if (number_of_chi2_bands > 0) {
                 // Calculating the chi2 time series
+                myTimer.Continue(t_chisq);
                 myChi2.CalculateChi2Series(number_of_chi2_bands, chi2_bands,
                     h, &strain_fft_segments[j], snr_segment, chi2_segment, &myFFT);
+                myTimer.Stop(t_chisq);
             }
 
             // Coping over the valid part
@@ -305,7 +316,8 @@ int main(int ac, char* av[]) {
     // Outputing the TriggerList
     myLogger.Log(GW::INFO,__func__,"Number of triggers found: %d", myTriggerList.size());
 
-    myMetaIOWriter.write_sngl_inspiral_table(myTriggerList);
+    if (!myTriggerList.empty())
+        myMetaIOWriter.write_sngl_inspiral_table(myTriggerList);
 
     // Writing out the SNR and chi2 time series
     if (!snr_outfile.empty()) {
@@ -323,6 +335,7 @@ int main(int ac, char* av[]) {
     double copy_time    = myTimer.Seconds(t_copy);
     double vari_time    = myTimer.Seconds(t_variance);
     double filt_time    = myTimer.Seconds(t_filter);
+    double chisq_time   = myTimer.Seconds(t_chisq);
     double gen_time     = myTimer.Seconds(t_generate);
     double clus_time    = myTimer.Seconds(t_cluster);
        double norm_time    = myTimer.Seconds(t_norm);
@@ -341,6 +354,8 @@ int main(int ac, char* av[]) {
                                        filt_time, filt_time / totaltime);
     myLogger.Log(GW::DEBUG,__func__,"Normalisation       : %f, %f %%",
                                        norm_time, norm_time / totaltime);
+    myLogger.Log(GW::DEBUG,__func__,"Chi-squared test    : %f, %f %%",
+                                       chisq_time, chisq_time / totaltime);
     myLogger.Log(GW::DEBUG,__func__,"Coping data         : %f, %f %%",
                                        copy_time, copy_time / totaltime);
     myLogger.Log(GW::DEBUG,__func__,"Clustering          : %f, %f %%",
index ffe024f..4588cf1 100644 (file)
@@ -76,8 +76,8 @@ int main(int ac, char* av[]) {
     GW::ExtrinsicWaveformParameters myExtrParams;\r
 \r
     // Determining the longest template, this will be the lighter configuration\r
-    myIntrParams["m1"]   = (float) m1_min;\r
-    myIntrParams["m2"]   = (float) m2_min;\r
+    myIntrParams["mass1"]   = (float) m1_min;\r
+    myIntrParams["mass2"]   = (float) m2_min;\r
     myIntrParams["flow"] = (float) flow;\r
 \r
     // Calculating the duration\r
@@ -196,8 +196,8 @@ int main(int ac, char* av[]) {
         cl_float m1 = m1_min + (m1_max - m1_min) * myNoise.RandReal();\r
         cl_float m2 = m2_min + (m2_max - m2_min) * myNoise.RandReal();\r
 \r
-        myIntrParams["m1"]   = (float) m1;\r
-        myIntrParams["m2"]   = (float) m2;\r
+        myIntrParams["mass1"]   = (float) m1;\r
+        myIntrParams["mass2"]   = (float) m2;\r
         myIntrParams["flow"] = (float) flow;\r
         myTaylorF2.Generate(myIntrParams, myExtrParams, output,\r
                                             sampling_rate, out_trial);\r
@@ -212,8 +212,8 @@ int main(int ac, char* av[]) {
         keep = true;\r
         for (int i = 0; i < myTemplateBank.templates.size(); i++) {\r
             bankParams = myTemplateBank.templates[i];\r
-            bank_m1 = boost::any_cast <float> (bankParams["m1"]);\r
-            bank_m2 = boost::any_cast <float> (bankParams["m2"]);\r
+            bank_m1 = boost::any_cast <float> (bankParams["mass1"]);\r
+            bank_m2 = boost::any_cast <float> (bankParams["mass2"]);\r
 \r
             // We check only the neighbours, we want to avoid parameter\r
             // scattering\r
index 9e0cf7d..43f5ad4 100644 (file)
@@ -35,8 +35,8 @@ namespace GW {
 
     CLIWaveform(int ac, char* av[]);
 
-    cl_float    get_m1()            const {return m_var_map["m1"].as<float>();}
-    cl_float    get_m2()            const {return m_var_map["m2"].as<float>();}
+    cl_float    get_m1()            const {return m_var_map["mass1"].as<float>();}
+    cl_float    get_m2()            const {return m_var_map["mass2"].as<float>();}
     cl_float    get_flow()          const {return m_var_map["flow"].as<float>();}
     cl_double   get_time_shift()    const {return m_var_map["time-shift"].as<double>();}
     cl_uint     get_sampling_rate() const {return m_var_map["sampling-rate"].as<uint>();}
index 36d528d..09a9dda 100644 (file)
@@ -21,8 +21,8 @@ GW::CLIWaveform::CLIWaveform(int ac, char* av[]) :
   CLIBase()
 {
   m_opt_desc.add_options()
-    ("m1",     po::value<float>()->default_value(0), "the mass of the first object in [solar mass]")
-    ("m2",     po::value<float>()->default_value(0), "the mass of the second object [solar mass]")
+    ("mass1",     po::value<float>()->default_value(0), "the mass of the first object in [solar mass]")
+    ("mass2",     po::value<float>()->default_value(0), "the mass of the second object [solar mass]")
     ("flow",   po::value<float>()->default_value(0), "the starting frequency [Hz]")
     ("time-shift",po::value<double>()->default_value(0), "the time shift for the generated waveform [s]")
     ("output", po::value<string>()->default_value(""), "the requested output variables")
index 3b586b1..f6cb139 100644 (file)
@@ -42,8 +42,8 @@ int main(int ac, char* av[]) {
     GW::ExtrinsicWaveformParameters  myExtParams;
 
     // The physical parameters of the binary system
-    myIntParams["m1"]     = myCli.get_m1();
-    myIntParams["m2"]     = myCli.get_m2();
+    myIntParams["mass1"]     = myCli.get_m1();
+    myIntParams["mass2"]     = myCli.get_m2();
     myIntParams["flow"]   = myCli.get_flow();
 
     myExtParams.time_shift    = myCli.get_time_shift();
index b197f50..914cd6c 100644 (file)
@@ -53,16 +53,15 @@ class MetaIO  {
 
         ~MetaIO();
 
-        void read_approximant(std::string& approximant,
-                              const std::string ligolw_table_name = 
-                              "process_params"
-                              );
+        void read_option_value(const std::string option_name,
+                               std::string& option_value,
+                               const std::string ligolw_table_name = 
+                               "process_params");
     
         void read_template_bank(std::vector<IntrinsicWaveformParameters>& 
                                 waveform_params,
                                 const std::string ligolw_table_name = 
-                                "sngl_inspiral"
-                                );
+                                "sngl_inspiral");
 
     private:
     
index cc9cc96..bd18bb8 100644 (file)
 #define _GWTemplatebank_H
 
 #include <string>
+#include <boost/algorithm/string/predicate.hpp>
 #include "array/GWArray.hpp"
 #include "fft/GWFFTBase.hpp"
 #include "GWToolsBase.hpp"
 #include "waveform/GWWaveformBase.hpp"
+#include "io/GWMetaIO.hpp"
 
 namespace GW {
 
@@ -41,6 +43,8 @@ template <typename T> class TemplateBank : public GWToolsBase
 
     TemplateBank(CLIBase* commif, LoggerBase* logger, Runtime* runtime);
        cl_int Read(const std::string filename);
+    cl_int ReadFromASCII(const std::string filename);
+    cl_int ReadFromMetaIO(const std::string filename);
 
     void   GetLongestTemplate(
             double &maxlength,                //!< returned length in seconds
@@ -103,7 +107,7 @@ template  <typename T> void TemplateBank<T>::GetLongestTemplate(
                  "Looping through on the %d bank templates.", templates.size());
 
     for (int i = 0; i < templates.size(); i++) {
-    length = mywaveform->Duration(templates[i]);
+        length = mywaveform->Duration(templates[i]);
         if (length > maxlength) {
             maxlength = length;
             idx       = i;
@@ -115,11 +119,28 @@ template  <typename T> void TemplateBank<T>::GetLongestTemplate(
 /******************************************************************************/
 /*!
  * TemplateBank::Read
+ * 
+ * Reads a template bank file by autodetecting the file format and redirecting
+ * to the appropriate method.
+ */
+/******************************************************************************/
+template <typename T> cl_int TemplateBank<T>::Read(const std::string filename)
+{
+    if (boost::algorithm::ends_with(filename, ".txt"))
+        return ReadFromASCII(filename);
+    else if (boost::algorithm::ends_with(filename, ".xml") ||
+            boost::algorithm::ends_with(filename, ".xml.gz"))
+        return ReadFromMetaIO(filename);
+}
+
+/******************************************************************************/
+/*!
+ * TemplateBank::ReadFromASCII
  *
  *  Reads a template bank file and populates the Template Bank
  */
 /******************************************************************************/
-template <typename T> cl_int TemplateBank<T>::Read(const std::string filename)
+template <typename T> cl_int TemplateBank<T>::ReadFromASCII(const std::string filename)
 {
     std::ifstream               bankFile;
     std::string                 line;
@@ -145,7 +166,9 @@ template <typename T> cl_int TemplateBank<T>::Read(const std::string filename)
 
        // Parsing the lines
     while (getline(bankFile, line)) {
-        if (bankFile.fail()) {break;}
+        if (bankFile.fail()) {
+            break;
+        }
 
         linestream.str("");
         linestream.clear();
@@ -201,6 +224,26 @@ template <typename T> cl_int TemplateBank<T>::Read(const std::string filename)
     return 0;
 };
 
+/******************************************************************************/
+/*!
+ * TemplateBank::ReadFromMetaIO
+ * 
+ * Reads a MetaIO template bank file and populates the Template Bank
+ */
+/******************************************************************************/
+template <typename T> cl_int TemplateBank<T>::ReadFromMetaIO(const std::string filename)
+{
+    MetaIO  mio(filename, m_logger);
+
+    m_logger->Log(GW::DEBUG, __func__, "Reading template bank file: %s", filename.c_str());
+    mio.read_option_value("--approximant", waveform_name);
+    m_logger->Log(GW::DEBUG, __func__, "Template bank waveform: %s", waveform_name.c_str());
+    mio.read_template_bank(templates);
+    number_of_templates = templates.size();
+    m_logger->Log(GW::DEBUG, __func__, "Number of templates read: %d", number_of_templates);
+    return 0;
+}
+
 } // end of namespace
 
 #endif
index 567254b..3a534e8 100644 (file)
@@ -143,8 +143,8 @@ template <typename T> class WaveformBase : public GWToolsBase
 template <typename T>  double WaveformBase<T>::Duration(
                               IntrinsicWaveformParameters wfParams)
 {
-    cl_float m1   = boost::any_cast <float> (wfParams["m1"]);
-    cl_float m2   = boost::any_cast <float> (wfParams["m2"]);
+    cl_float m1   = boost::any_cast <float> (wfParams["mass1"]);
+    cl_float m2   = boost::any_cast <float> (wfParams["mass2"]);
     cl_float flow = boost::any_cast <float> (wfParams["flow"]);
 
     cl_float Mtot  = (m1 + m2) * MSun;
index c801ae3..ad003e7 100644 (file)
@@ -170,8 +170,8 @@ template <typename T>  int TaylorF2<T>::Generate(
 
        // Converting the parameters;
 
-       float  m1         = boost::any_cast <float> (intParams["m1"]);
-       float  m2         = boost::any_cast <float> (intParams["m2"]);
+       float  m1         = boost::any_cast <float> (intParams["mass1"]);
+       float  m2         = boost::any_cast <float> (intParams["mass2"]);
        float  flow       = boost::any_cast <float> (intParams["flow"]);
     float  distance   = extParams.distance;
 
index f06b453..906e985 100644 (file)
@@ -35,18 +35,17 @@ __kernel void complexFloatSimpleMax(
 
     event_t copyEvents[1];
     copyEvents[0] = async_work_group_copy(peaks, &snr_series[start_index], group_size * 2, 0);
-    wait_group_events (1, copyEvents);
+    wait_group_events(1, copyEvents);
 
-       if ( local_id == 0) {
+       if (local_id == 0) {
                for (i = 0; i < group_size; i++) {
-            absv =  sqrt(peaks[2 * i] * peaks[2 * i] + peaks[2 * i + 1] * peaks[2 * i + 1]);
-                       if ( absv > peak_value ) {
+            absv = peaks[2 * i] * peaks[2 * i] + peaks[2 * i + 1] * peaks[2 * i + 1];
+                       if (absv > peak_value) {
                                peak_value = absv;
                        peak_time  = time_shift + i * delta_t;
                        }
                }
-
-        peak_list[2 * group_id]     = peak_value;
+        peak_list[2 * group_id]     = sqrt(peak_value);
         peak_list[2 * group_id + 1] = peak_time;
     }
 
index 765d0ee..f659dae 100644 (file)
@@ -1,6 +1,6 @@
 /*! \file
  *
- *   \brief MetaIO Ligo Lightweight format reader/write modul
+ *   \brief MetaIO Ligo Lightweight format reader/write module
  *   \author Karsten Wiesner
  *
  *   \version 1.0
@@ -8,6 +8,7 @@
  *
  */
 
+#include <boost/algorithm/string.hpp>
 #include "io/GWMetaIO.hpp"
 
 using namespace std;
@@ -53,21 +54,22 @@ MetaIO::~MetaIO()
 
 /******************************************************************************/
 /*!
- * \brief read the approximant from the program options
+ * \brief read a particular option from the program command line
  *        this templatebank file was generated with 
  *        from key: process_paramsgroup:process_params
  */
 /******************************************************************************/
-void MetaIO::read_approximant(std::string& approximant,
+void MetaIO::read_option_value(const std::string option_name,
+                              std::string& option_value,
                               const std::string ligolw_table_name)
 {
-    if ( MetaioOpenFile( m_env, m_filename.c_str() ) ) {
-        m_logger->Log(GW::ERROR, __func__,"Error in MetaioOpenFile %s", 
+    if (MetaioOpenFile( m_env, m_filename.c_str())) {
+        m_logger->Log(GW::ERROR, __func__, "Error in MetaioOpenFile %s", 
                       m_env->mierrmsg.data);
     }
     
     // read the process_params table into m_env
-    if ( MetaioOpenTableOnly( m_env, ligolw_table_name.c_str()) ) {
+    if (MetaioOpenTableOnly( m_env, ligolw_table_name.c_str())) {
         m_logger->Log(GW::ERROR, __func__,"Error in MetaioOpenTableOnly %s", 
                       m_env->mierrmsg.data);
     }
@@ -80,23 +82,23 @@ void MetaIO::read_approximant(std::string& approximant,
     }
 
     int metaio_get_row_ret;
-    string prog_option("--approximant");
     
     // extract the values from each row until we find "approximant"
-    while ( (metaio_get_row_ret= MetaioGetRow(m_env)) ) {
-        if (m_env->ligo_lw.table.elt[2].data.lstring.data == prog_option) {
-            approximant = m_env->ligo_lw.table.elt[4].data.lstring.data;
-            m_logger->Log(GW::DEBUG, __func__,"found approximant: %s", 
-                          approximant.c_str());
+    while ((metaio_get_row_ret= MetaioGetRow(m_env))) {
+        if (m_env->ligo_lw.table.elt[2].data.lstring.data == option_name) {
+            option_value = m_env->ligo_lw.table.elt[4].data.lstring.data;
+            m_logger->Log(GW::DEBUG, __func__, "%s = %s",
+                            option_name.c_str(),
+                            option_value.c_str());
             break;
         }
     }
-    if ( metaio_get_row_ret < 0 )  
-        m_logger->Log(GW::ERROR, __func__,"MetaioGetRow %s", 
+    if (metaio_get_row_ret < 0)
+        m_logger->Log(GW::ERROR, __func__,"MetaioGetRow %s",
                       m_env->mierrmsg.data);
 
-    if ( MetaioClose(m_env) )
-        m_logger->Log(GW::ERROR, __func__,"Error in MetaioClose %s", 
+    if (MetaioClose(m_env))
+        m_logger->Log(GW::ERROR, __func__,"Error in MetaioClose %s",
                       m_env->mierrmsg.data);
 }
 
@@ -111,41 +113,49 @@ void MetaIO::read_template_bank(std::vector<IntrinsicWaveformParameters>&
                                 waveform_params_vector,
                                 const std::string ligolw_table_name)
 {
-  if ( MetaioOpenFile( m_env, m_filename.c_str() ) ) {
+    // get low frequency cutoff for the whole template
+    // (need to do this before MetaioOpenFile())
+    std::string flow_str;
+
+    read_option_value("--low-frequency-cutoff", flow_str);
+
+    if (MetaioOpenFile( m_env, m_filename.c_str())) {
         m_logger->Log(GW::ERROR, __func__,"Error in MetaioOpenFile %s", 
                       m_env->mierrmsg.data);
-  }
+    }
         
-  // read the sngl_inspiral table into m_env
-  if ( MetaioOpenTableOnly( m_env, ligolw_table_name.c_str()) ) {
+    // read the sngl_inspiral table into m_env
+    if (MetaioOpenTableOnly( m_env, ligolw_table_name.c_str())) {
         m_logger->Log(GW::ERROR, __func__,"Error in MetaioOpenTableOnly %s", 
                       m_env->mierrmsg.data);
-  }
+    }
     
-  // log out the columns (specifying the values in a templatebank row)
-  for (int i=0; i < m_env->ligo_lw.table.numcols; i++) {
-    m_logger->Log(GW::DEBUG, __func__,"sngl_inspiral table column= [%s]%s",
-                  MetaioTypeText(m_env->ligo_lw.table.col[i].data_type),
-                  m_env->ligo_lw.table.col[i].name);
-  }
+    // log out the columns (specifying the values in a templatebank row)
+    for (int i=0; i < m_env->ligo_lw.table.numcols; i++) {
+        std::vector<std::string> strs;
+
+        boost::split(strs, m_env->ligo_lw.table.col[i].name, boost::is_any_of(":"));
+        m_logger->Log(GW::DEBUG, __func__,"sngl_inspiral table column = [%s] %s",
+                      MetaioTypeText(m_env->ligo_lw.table.col[i].data_type),
+                      strs.back().c_str());
+    }
 
-  int metaio_get_row_ret;
+    int metaio_get_row_ret;
 
-  // extract the values from each row into waveform_params_vector 
-  while ( (metaio_get_row_ret= MetaioGetRow(m_env)) ) {
-      
-    IntrinsicWaveformParameters wav_param_map;
+    // extract the values from each row into waveform_params_vector 
+    while ((metaio_get_row_ret= MetaioGetRow(m_env))) {
+        IntrinsicWaveformParameters wav_param_map;
 
     // loop over columns   
-    for (int i=0; i < m_env->ligo_lw.table.numcols; i++)
-    {
+    for (int i=0; i < m_env->ligo_lw.table.numcols; i++) {
+      std::vector<std::string> strs;
          string     name;
          boost::any value;
 
-         name = m_env->ligo_lw.table.col[i].name;
+      boost::split(strs, m_env->ligo_lw.table.col[i].name, boost::is_any_of(":"));
+      name = strs.back();
 
-         switch(m_env->ligo_lw.table.col[i].data_type)
-         {
+         switch (m_env->ligo_lw.table.col[i].data_type) {
            // integer types:
            case METAIO_TYPE_INT_4S: value= m_env->ligo_lw.table.elt[i].data.int_4s;
              break;
@@ -181,14 +191,15 @@ void MetaIO::read_template_bank(std::vector<IntrinsicWaveformParameters>&
               m_logger->Log(GW::ERROR, __func__,
                             "Element data type not specified");
          }
-      wav_param_map.insert(pair<string, boost::any>(name, value));
+      wav_param_map[name] = value;
     }
+    wav_param_map["flow"] = (float)atof(flow_str.c_str());
     waveform_params_vector.push_back(wav_param_map);
   }
-  if ( metaio_get_row_ret < 0 )  
+  if (metaio_get_row_ret < 0)
     m_logger->Log(GW::ERROR, __func__,"MetaioGetRow %s", m_env->mierrmsg.data);
     
-  if ( MetaioClose(m_env) )
+  if (MetaioClose(m_env))
         m_logger->Log(GW::ERROR, __func__,"Error in MetaioClose %s", 
                       m_env->mierrmsg.data);
 }
@@ -285,8 +296,8 @@ void MetaIOWriter::assign_single_inspiral_table(SnglInspiralTable* sit,
     sit->alpha=  t_it->ExtrParams.psi;
     sit->alpha1= t_it->ExtrParams.time_shift;
     
-    sit->mass1= boost::any_cast <float>   (t_it->IntrParams["m1"]);
-    sit->mass2= boost::any_cast <float>   (t_it->IntrParams["m2"]);
+    sit->mass1= boost::any_cast <float>   (t_it->IntrParams["mass1"]);
+    sit->mass2= boost::any_cast <float>   (t_it->IntrParams["mass2"]);
     sit->f_final= boost::any_cast <float> (t_it->IntrParams["flow"]);
     sit->mtotal = sit->mass1 + sit->mass2;
     sit->eta = sit->mass1 * sit->mass2 / (sit->mtotal * sit->mtotal);
index fed6307..f39d3e9 100644 (file)
@@ -117,7 +117,7 @@ BOOST_FIXTURE_TEST_CASE(metaio_test_1, METAIO_Fixture_1)
     
   std::string approximant;   
     
-  dut->read_approximant(approximant);
+  dut->read_option_value("--approximant", approximant);
   
   BOOST_TEST_MESSAGE("read approximant waveform model: " <<  approximant);