stfinv.cc

Go to the documentation of this file.

#define STFINV_STFINV_C_VERSION \
  "STFINV_STFINV_C   V1.3"

#include <stfinv/stfinv.h>
#include <stfinv/error.h>
#include <stfinv/stfinvany.h>

namespace stfinv {

  namespace capi {

    stfinv::STFEngine* Pengine=0;

  } // namespace capi

} // namespace stfinv

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

void initstfinvenginewithpairs(struct CTriples triples,
                               struct CWaveform stf,
                               struct CPairs pairs,
                               char* parameters)
{
  // remove existing engine if has previously been initialized
  freestfinvengine();

  // convert parameter string
  std::string cxxparameters(parameters);

  // convert pointer to source correction filter array
  stfinv::Waveform cxxstf;
  cxxstf.sampling=stf.sampling;
  aff::LinearShape shape(0, cxxstf.sampling.n-1, 0);
  cxxstf.series
    =stfinv::Tseries(shape, 
                     aff::SharedHeap<Tvalue>(stf.series,
                                             cxxstf.sampling.n));

  // convert pointer triples
  // notice: it is not required to check consistency here; all header fields
  // are transferred to the C++ containers; the C++ engine will check
  // consistency during its initialization
  STFINV_assert(triples.n>0, "no triples provided");
  stfinv::Tvectoroftriples cxxtriples(triples.n);
  for (int i=0; i<triples.n; ++i)
  {
    CWaveformTriple ctriple=triples.triples[i];
    cxxtriples[i].header=ctriple.header;
    const int& n=cxxtriples[i].header.sampling.n;
    shape=aff::LinearShape(0, n-1, 0);
    cxxtriples[i].data
      =stfinv::Tseries::Tcoc(shape, 
                       aff::SharedHeap<Tvalue>::Tcoc(ctriple.data, n));
    cxxtriples[i].synthetics
      =stfinv::Tseries::Tcoc(shape, 
                       aff::SharedHeap<Tvalue>::Tcoc(ctriple.synthetics, n));
    cxxtriples[i].convolvedsynthetics
      =stfinv::Tseries(shape, 
                       aff::SharedHeap<Tvalue>(ctriple.convolvedsynthetics, n));
  }

  // convert pointer pairs
  // notice: it is not required to check consistency here; all header fields
  // are transferred to the C++ containers; the C++ engine will check
  // consistency during its initialization
  stfinv::Tvectorofpairs cxxpairs(pairs.n);
  for (int i=0; i<pairs.n; ++i)
  {
    CWaveformPair cpair=pairs.pairs[i];
    cxxpairs[i].sampling=cpair.sampling;
    const int& n=cxxpairs[i].sampling.n;
    shape=aff::LinearShape(0, n-1, 0);
    cxxpairs[i].synthetics
      =stfinv::Tseries::Tcoc(shape, 
                       aff::SharedHeap<Tvalue>::Tcoc(cpair.synthetics, n));
    cxxpairs[i].convolvedsynthetics
      =stfinv::Tseries(shape, 
                       aff::SharedHeap<Tvalue>(cpair.convolvedsynthetics, n));
  }

  // create engine
  stfinv::capi::Pengine=new stfinv::STFEngine(cxxtriples, cxxstf,
                                              cxxpairs,
                                              cxxparameters);
} // void initstfinvenginewithpairs

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

void initstfinvengine(struct CTriples triples,
                      struct CWaveform stf,
                      char* parameters)
{
  struct CPairs pairs;
  pairs.n=0;
  initstfinvenginewithpairs(triples, stf, pairs, parameters);
} // void initstfinvengine

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

void runstfinvengine()
{
  STFINV_assert(stfinv::capi::Pengine != 0,
                "runstfinvengine(): engine is not initialized!");
  stfinv::capi::Pengine->run();
} // void runstfinvengine()

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

void freestfinvengine()
{
  if (stfinv::capi::Pengine != 0) { delete stfinv::capi::Pengine; }
} // void freestfinvengine()

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

void printengines()
{
  stfinv::engines();
} // void printengines()

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

void printhelp()
{
  stfinv::help();
} // void printhelp()

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

void printusage(char* id)
{
  std::string selectid(id);
  stfinv::usage(selectid);
} // void printhelp(age(char* id)

/* ----- END OF stfinv.cc ----- */