stfinvany.cc

Go to the documentation of this file.

#define STFINV_STFINVANY_CC_VERSION \
  "STFINV_STFINVANY_CC   V1.3"

#include <stfinv/stfinvany.h>
#include <stfinv/stfinvfdleastsquares.h>
#include <stfinv/stfinvfixedstf.h>
#include <stfinv/stfinvidentity.h>
#include <stfinv/parameterhandler.h>
#include <stfinv/stfinvany_summary_usage.h>
#include <stfinv/stfinvany_description_usage.h>
#include <stfinv/stfinv_summary_usage.h>
#include <stfinv/stfinv_description_usage.h>
#include <stfinv/error.h>
#include <stfinv/tools.h>

namespace stfinv {
  
  STFEngine::STFEngine(const stfinv::Tvectoroftriples& triples,
                       const stfinv::Waveform& stf,
                       const std::string& parameters)
  {
    stfinv::Tvectorofpairs pairs;
    pairs.clear();
    this->initialize(triples, stf, pairs, parameters);
  }

  /*----------------------------------------------------------------------*/
  STFEngine::STFEngine(const stfinv::Tvectoroftriples& triples,
                       const stfinv::Waveform& stf,
                       const stfinv::Tvectorofpairs& pairs,
                       const std::string& parameters)
  {
    this->initialize(triples, stf, pairs, parameters);
  }

  /*----------------------------------------------------------------------*/

  void STFEngine::initialize(const stfinv::Tvectoroftriples& triples,
                             const stfinv::Waveform& stf,
                             const stfinv::Tvectorofpairs& pairs,
                             const std::string& parameters)
  {
    std::string para=parameters;
    std::string id=stfinv::tools::clipstring(para, ":");
    if (id == std::string(stfinv::STFEngineIdentity::ID))
    {
      Mengine=new stfinv::STFEngineIdentity(triples, stf, para);
    }
    /*
    else if (id == std::string(stfinv::STFEngineFixedWavelet::ID))
    {
      STFINV_assert(pairs.size()==0,
              "ERROR: engine does not support additional time series pairs");
      Mengine=new stfinv::STFEngineFixedWavelet(triples, stf, para);
    }
    */
    else if ((id == std::string(stfinv::STFEngineFDLeastSquares::ID))
             || (id == std::string("fbd")))
    {
      STFINV_report_assert((id == std::string(stfinv::STFEngineFDLeastSquares::ID)),
                           "The ID \"fbd\" for this engine is deprecated",
                           "The correct ID of the Fourier domain least "
                           "squares engine is \"" <<
                           stfinv::STFEngineFDLeastSquares::ID <<
                           "\".\n"
                           "The former ID \"fbd\" may vanish in the future "
                           "and should no longer be used.");
      if (pairs.size()>0)
      {
        Mengine=new stfinv::STFEngineFDLeastSquares(triples, stf, 
                                                        pairs, para);
      }
      else
      {
        Mengine=new stfinv::STFEngineFDLeastSquares(triples, stf, para);
      }
    }
    else
    {
      std::cerr << "ERROR: engine ID " << id << " is unkown!" << std::endl;
      STFINV_abort("aborting since engine ID is not recognized");
    }
    STFINV_assert(Mengine!=0, "engine was not created correctly");
  }

  /*----------------------------------------------------------------------*/

  STFEngine::~STFEngine() 
  {
    delete Mengine;
  } // STFEngine::~STFEngine()

  /*----------------------------------------------------------------------*/

  void STFEngine::engines(std::ostream& os)
  {
    os << "Available procedures:" << std::endl;
    os << "---------------------" << std::endl;
    tools::report_engine<STFEngineIdentity>(os);
    // tools::report_engine<STFEngineFixedWavelet>(os);
    tools::report_engine<STFEngineFDLeastSquares>(os);
  } // void STFEngine::help(std::ostream& os=std::cout)

  /*----------------------------------------------------------------------*/

  void STFEngine::help(std::ostream& os)
  {
    os << stfinv_summary_usage;
    os << std::endl;
    STFEngine::engines(os);
    os << std::endl;
    STFEngineIdentity::classhelp(os);
    os << std::endl;
    STFEngineFDLeastSquares::classhelp(os);
    os << std::endl;
    STFFourierDomainEngine::classhelp(os);
    os << std::endl;
    STFBaseEngine::classhelp(os);
    os << std::endl;
    os << stfinvany_summary_usage;
  } // void STFEngine::help(std::ostream& os=std::cout)

  /*----------------------------------------------------------------------*/

  void STFEngine::usage(const std::string& id, std::ostream& os)
  {
    os << stfinv_description_usage;
    os << std::endl;
    if (id == std::string(stfinv::STFEngineIdentity::ID))
    {
      stfinv::STFEngineIdentity::classusage(os);
    }
    else if ((id == std::string(stfinv::STFEngineFDLeastSquares::ID)))
    {
      stfinv::STFEngineFDLeastSquares::classusage(os);
    }
    else
    {
      std::cerr << "ERROR: engine ID " << id << " is unkown!" << std::endl;
      STFINV_abort("aborting since engine ID is not recognized");
    }
    os << std::endl;
    os << stfinvany_description_usage;
  } // void STFEngine::help(std::ostream& os=std::cout)

  /*======================================================================*/

  void engines(std::ostream& os)
  {
    STFEngine::engines(os);
  } // void engines(std::ostream& os)

  void help(std::ostream& os)
  {
    STFEngine::help(os);
  } // void help(std::ostream& os=std::cout)

  void usage(const std::string& id, std::ostream& os)
  {
    STFEngine::usage(id, os);
  } // void usage(const std::string& id, std::ostream& os)

} // namespace stfinv

/* ----- END OF stfinvany.cc ----- */