taperstf()

void stfinv::STFFourierDomainEngine::taperstf ( )

private

apply a time domain taper to the correction filter response.

Apply a time domain taper to the impulse response of the source time function correction filter.

Definition at line 577 of file stfinvfourier.cc.

References stfinv::STFBaseEngine::dt(), Mapplystftaper, stfinv::STFBaseEngine::Mdebug, Mfftenginestf, Mtt1, Mtt2, Mtt3, Mtt4, stfinv::STFBaseEngine::nsamples(), STFINV_assert, STFINV_debug, STFINV_value, stfseries(), and stfspec().

Referenced by fftoutput().

  {
    STFINV_debug(Mdebug&16, "STFFourierDomainEngine::taperstf()",
                 STFINV_value(Mapplystftaper));
    if (this->Mapplystftaper)
    {
      // transform correction filter to time domain
      Mfftenginestf.c2r();
      Tfftengine::TAseries thestfseries=this->stfseries();
      thestfseries *= Mfftenginestf.scale_series(this->dt());
      // apply taper
      /*
       * Concept of application to periodic time series allowing for negative
       * values of taper times:
       *
       * All samples between t2 and t3 remain unaltered. It is reasonable to
       * process the taper starting at t3 passing t4 to t1 and then ending at
       * t2. Behind this is the concept that time series are implicitely
       * periodic in discrete Fourier transform.
       */
      // samples in series
      int nsamples=thestfseries.size(0);
      // duration of time series
      double T=this->dt()*nsamples;
      // make sure taper definition is not longer than time series.
      STFINV_assert((this->Mtt4-this->Mtt1)<T,
                    "Taper width is larger than length of time series");
      // set taper time values under conpect of periodic series
      double tt3=this->Mtt3;
      double tt4=this->Mtt4;
      double tt1=this->Mtt1+T;
      double tt2=this->Mtt2+T;
      // sample to start at
      int l3=int(std::floor(tt3/this->dt()));
      int l2=int(std::ceil(tt2/this->dt()));
      STFINV_debug(Mdebug&16, "STFFourierDomainEngine::taperstf()",
                   STFINV_value(T) << "\n   " <<
                   STFINV_value(this->dt()) << "\n   " <<
                   STFINV_value(nsamples) << "\n   " <<
                   STFINV_value(tt3) << "\n   " <<
                   STFINV_value(tt4) << "\n   " <<
                   STFINV_value(tt1) << "\n   " <<
                   STFINV_value(tt2) << "\n   " <<
                   STFINV_value(l3) << "\n   " <<
                   STFINV_value(l2));
      for (int l=l3; l<=l2; ++l)
      {
        // time of sample
        double t=l*this->dt();
        // index to series
        int rl = l%nsamples;
        if (rl < 0) { rl += nsamples; }
        STFINV_assert(((rl >= thestfseries.f(0)) && 
                       (rl <= thestfseries.l(0))),
                      "Index out of range. Internal programming error! "
                      "Report as bug!")
        // taper factor
        double factor=1.;
        if ( (t>=tt3) && (t<=tt4) && (tt4>tt3) )
        {
          factor=0.5+0.5*cos(M_PI*(t-tt3)/(tt4-tt3));
        }
        else if ( (t>tt4) && (t<tt1) )
        {
          factor=0.;
        }
        else if ( (t>=tt1) && (t<=tt2) && (tt2>tt1) )
        {
          factor=0.5-0.5*cos(M_PI*(t-tt1)/(tt2-tt1));
        }
        // apply to series
        thestfseries(rl) = thestfseries(rl)*factor;
        STFINV_debug(Mdebug&16, "STFFourierDomainEngine::taperstf()",
                     STFINV_value(t) << " " <<
                     STFINV_value(l) << " " <<
                     STFINV_value(rl) << " " <<
                     STFINV_value(factor));
      }
      // transform correction filter to Fourier domain
      Mfftenginestf.r2c();
      this->stfspec() *= Mfftenginestf.scale_spectrum(this->dt());
    } // if (this->Mapplystftaper)
  } // void STFFourierDomainEngine::taperstf()

Here is the call graph for this function:

Here is the caller graph for this function: