miscfunc.h

Go to the documentation of this file.

#ifndef MISCFUNC_H_INCLUDED
#define MISCFUNC_H_INCLUDED
#include "types.h"
#include <vector>
#include "CFatalException.h"
#include "TsSpectrum.h"
#include <boost/numeric/ublas/vector.hpp>
#include <iostream>
#include <functional>

class CMTStation; //forward declaration, we include miscfunc.h from CMTStation
namespace ublas = boost::numeric::ublas;
void NormEnvelope(std::vector<double>::iterator Inputbegin,std::vector<double>::iterator Inputend , std::vector<double> &Output);
void Hilbert(std::vector<double>::iterator Inputbegin,std::vector<double>::iterator Inputend , std::vector<double> &Output);
double Cross(ttsdata Master, ttsdata Corr, const int startpoint, const int endpoint);



inline double Commute(dcomp A, dcomp B) //calculates Commutator of two complex numbers
{
    return(A.real() * B.imag() - B.real() * A.imag());
    
}

inline int FuzzComp(double par1, double par2, double tolerance)
{ 
    double lower;
    double higher;
    double target;
    
    target = par2;
    lower = par1 - tolerance;
    higher = par1 + tolerance;
    if ( (lower <= par2) && ( higher >= par2) )
        return(1);
        else return(0);
    //return (((par1-tolerance) <= par2) && ((par1+tolerance) >= par2)); 
}

//! perform spectral multipliaction on two vector style container and write the result to output

/*! Do_Spec_Mul takes two input vectors, Master and Corr of the same length, writes either the convolution or correlation
 * into the vector output, depending on docorrel
 */
template<typename ts_type>
void Do_Spec_Mul(const ts_type &Master,const ts_type &Corr, ts_type &Output,const bool docorrel)
{
        if (Corr.size() != Master.size()) //if input sizes are different
                throw CFatalException("In Correl: Master.size != Corr.size !"); //throw exception
        if (Output.size() != Master.size()) //if ouput vector doesn't have the right length
            Output.resize(Master.size()); //adjust
        
        TsSpectrum SpecCalc(false); //Create an object to calculate spectra
        tcompdata MasterSpec(Master.size()/2+1), CorrSpec(Corr.size()/2+1); //some temporary objects
        SpecCalc.CalcSpectrum(Master.begin(),Master.end(), MasterSpec.begin(),MasterSpec.end()); // calc spectrum for master
        SpecCalc.CalcSpectrum(Corr.begin(),Corr.end(), CorrSpec.begin(),CorrSpec.end()); // and for corr
        tcompdata CrossPower;
        if (docorrel) //if we want to do a correlation
        {
                std::transform(MasterSpec.begin(),MasterSpec.end(),CorrSpec.begin(),back_inserter(CrossPower), //we have to multiply
                                boost::bind<std::complex<double> >( //Master elements with the conjugate of Corr elements and write
                                                        std::multiplies<std::complex<double> >(), //into CrossPower
                                                        _1,
                                                        boost::bind<std::complex<double> >(&std::conj<double>,_2)));
        }
        else //if convolution
        {
                std::transform(MasterSpec.begin(),MasterSpec.end(),CorrSpec.begin(),back_inserter(CrossPower),
                                                                std::multiplies<std::complex<double> >()); //just multiply elements in Master with elements in Corr
        }
        SpecCalc.CalcTimeSeries(CrossPower.begin(),CrossPower.end(),Output.begin(),Output.end()); //Calculate the timeseries from CrossPower
}

//! A convenience wrapper to calculate correlations
template<typename ts_type>
void Correl(const ts_type &Master,const ts_type &Corr, ts_type &Output)
{
        Do_Spec_Mul(Master,Corr,Output,true);
}
//! A convenience wrapper to calculate convolution
template<typename ts_type>
void Convolve(const ts_type &Master,const ts_type &Corr, ts_type &Output)
{
        Do_Spec_Mul(Master,Corr,Output,false);
}
#endif

---