initstfinvenginewithpairs()

void initstfinvenginewithpairs	(	struct CTriples	triples,
		struct CWaveform	stf,
		struct CPairs	pairs,
		char *	parameters
	)

Initialize the engine and pass additional time series to be convolved on the fly.

The purpose of this function in comparion to initstfinvengine() is explained in the comments to parameter pairs.

Parameters

triples	This function expects a struct CTriples containing references to the users workspace for recorded time series as well as synthetic time series. These will be used as input. As a third set a reference to a workspace for synthetic time series convolved with the source correction filter is expected. The latter will be used as output.
stf	The struct CWaveform presents a reference to the users work space for the source correction filter time series. It will be used to present the result of the processing to the user.
pairs	The struct CPairs presents a reference to the users work space for additional synthetic time series. These time series will not be used to determine the optimal source correction filter filter, but will be convolved with the obtained source time function on the fly. This is useful in particular with forward modelling code which uses a band limited source time function for the initial synthetics already. This source time function can be passed through this argument and will then be convolved with the optimized source correction filter, such that the result of the convolution is appropriate to obtain synthetics which provide a reduced misift with respect to the data.
parameters	Parameters to select one of the engines as well as to control the engines are passed in a character sequence. See also How to construct parameter strings

Definition at line 71 of file stfinv.cc.

References CWaveformTriple::convolvedsynthetics, CWaveformPair::convolvedsynthetics, CWaveformTriple::data, freestfinvengine(), CWaveformTriple::header, CWaveformHeader::n, CTriples::n, CPairs::n, CPairs::pairs, stfinv::capi::Pengine, CWaveformPair::sampling, CTripleHeader::sampling, stfinv::Waveform::sampling, CWaveform::sampling, stfinv::Waveform::series, CWaveform::series, STFINV_assert, CWaveformTriple::synthetics, CWaveformPair::synthetics, and CTriples::triples.

Referenced by initstfinvengine().

{
  // 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

Here is the call graph for this function:

Here is the caller graph for this function: