CppNoddy::FT Namespace Reference

Some algorithms associated with Fourier transforms of CppNoddy container data. More...

Functions
OneD_Node_Mesh< D_complex >	shift (const OneD_Node_Mesh< D_complex > &ft)
	Shift the frequency spectrum obtained from dft to give positive and negative freq. More...
OneD_Node_Mesh< D_complex >	ishift (const OneD_Node_Mesh< D_complex > &ft)
	Invert the shif operation to recover a spectrum in the form that is expected by the idft routine. More...
OneD_Node_Mesh< D_complex >	dft_with_shift (const OneD_Node_Mesh< D_complex > &f)
	A wrapper that calls the 'dft' method above followed by the 'shift' method. More...
TwoD_Node_Mesh< D_complex >	dft_with_shift (const TwoD_Node_Mesh< D_complex > &f)
OneD_Node_Mesh< D_complex >	idft_with_ishift (const OneD_Node_Mesh< D_complex > &ft, double origin=0)
	A wrapper that calls the 'ishift' method above followed by the 'idft' method. More...
TwoD_Node_Mesh< D_complex >	idft_with_ishift (const TwoD_Node_Mesh< D_complex > &ft, double origin=0)
OneD_Node_Mesh< D_complex >	dft (const OneD_Node_Mesh< D_complex > &f)
	(Slow) DFT of the real data (x_i,f_i), i = 0, ... N-1; N must be EVEN. More...
OneD_Node_Mesh< D_complex >	idft (const OneD_Node_Mesh< D_complex > &ft, double origin=0)
	(Slow) Inverse DFT of the complex data (omega_i,F_i), i = 0,...,N-1; N must be EVEN. More...

Detailed Description

Some algorithms associated with Fourier transforms of CppNoddy container data.

Function Documentation

dft()

OneD_Node_Mesh< D_complex > CppNoddy::FT::dft

(

const OneD_Node_Mesh< D_complex > &

f

)

(Slow) DFT of the real data (x_i,f_i), i = 0, ... N-1; N must be EVEN.

Parameters

f	The data to be (discrete) Fourier transformed.

Returns

The Fourier transform in "frequency" space (omega_i,F_i). The N frequencies are omega_i = 0, domega,..., (N-1)*domega. The SECOND half of the spectrum provides the -ve frequencies (as in MATLAB).

Definition at line 88 of file FT.cpp.

                                                                        {
      const D_complex I(0.0,1.0); // imaginary unit
      // number of samples in the signal
      std::size_t N = f.get_nnodes();
      // time step in the signal (has to be constant)
      double dt = f.coord(1)-f.coord(0);
      // sample frequency (rad) is related to inverse of "time" step
      double fs = 2*M_PI/dt;
      // frequency step between frequency nodes
      // - largest frequency is (N-1)*df=(N-1)*fs/N
      double df = fs/N;      
      // container to return the Fourier spectrum
      OneD_Node_Mesh<D_complex> ft( f.nodes(), f.get_nvars() );
      //
      const double Wn = 2*M_PI/N;
      // slow FT
      for ( std::size_t k = 0; k < N; ++k ) {
        // set the frequency
        ft.coord(k) = k*df;  // 0,df,...,(N-1)*df
        //
        //
        // t = n*dt
        // omega = k*df
        // df = (2*pi/dt)/N 
        //
        // variables are all initialised to zero
        DenseVector<D_complex> vars( f.get_nvars(), 0.0 );
        for ( std::size_t n = 0; n < N; ++n ) {
            vars += f.get_nodes_vars(n)*exp(-I*Wn*double(k*n));
        }
        // multiply by "dt" to make this correlate with analytical
        // results from the FT integral 
        ft.set_nodes_vars(k,vars*dt);
      }
      return ft;
    } 

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), f, and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::set_nodes_vars().

Referenced by dft_with_shift(), and main().

dft_with_shift() [1/2]

OneD_Node_Mesh< D_complex > CppNoddy::FT::dft_with_shift

(

const OneD_Node_Mesh< D_complex > &

f

)

A wrapper that calls the 'dft' method above followed by the 'shift' method.

Returns

The Fourier transform in "frequency" space (omega_i,F_i). The N frequencies are omega_i = -(N/2)*domega, ..., -domega , 0 , +domega, ... ,+(N/2-1)*domega.

Definition at line 48 of file FT.cpp.

                                                                                   {
      return shift(dft(f));
    }

References dft(), f, and shift().

Referenced by dft_with_shift(), and main().

dft_with_shift() [2/2]

TwoD_Node_Mesh< D_complex > CppNoddy::FT::dft_with_shift

(

const TwoD_Node_Mesh< D_complex > &

f

)

Definition at line 52 of file FT.cpp.

                                                                                  {
      // assume that we idft each ft(.,node)
      unsigned ny = f.get_nnodes().second;
      unsigned nx = f.get_nnodes().first;      
      TwoD_Node_Mesh<D_complex> FTsoln( f.xnodes(), f.ynodes(), f.get_nvars());
      for ( unsigned jy = 0; jy < ny; ++jy ) {
        OneD_Node_Mesh<D_complex> mesh = f.get_xsection_at_ynode(jy);
        OneD_Node_Mesh<D_complex> ftmesh = FT::dft_with_shift(mesh);
        for ( unsigned jx = 0; jx < nx; ++jx ) {
          FTsoln.xcoord(jx)=ftmesh.coord(jx);
          FTsoln.set_nodes_vars( jx, jy, ftmesh.get_nodes_vars(jx) );
        }
      }
      return FTsoln;
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), dft_with_shift(), f, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nodes_vars(), CppNoddy::TwoD_Node_Mesh< _Type >::set_nodes_vars(), and CppNoddy::TwoD_Node_Mesh< _Type >::xcoord().

idft()

OneD_Node_Mesh< D_complex > CppNoddy::FT::idft	(	const OneD_Node_Mesh< D_complex > &	ft,
		double	origin = 0
	)

(Slow) Inverse DFT of the complex data (omega_i,F_i), i = 0,...,N-1; N must be EVEN.

Parameters

ft	The frequency spectrum in the (unshifted) format.
origin	The position of the first data point returned.

Returns

The inversion data (origin+x_i, f_i).

Definition at line 153 of file FT.cpp.

                                                                                         {
      const D_complex I(0.0,1.0); // imaginary unit
      // number of "frequencies" in the data
      std::size_t N = ft.get_nnodes();
      // (uniform) frequency step in the data
      double df = ft.coord(1)-ft.coord(0);
      // sample frequency
      double fs = N*df;
      // time step in output signal
      double dt = 2*M_PI/fs;
      // NOTE: dt*df = 2*pi/N
      //
      // containter to return the "time series" in
      OneD_Node_Mesh<D_complex> f( ft );
      //
      const double Wn = 2*M_PI/N;
      // number of variables at each time/frequency
      const std::size_t nVars( ft.get_nvars() );
      // slow inverse FT
      for ( std::size_t n = 0; n < N; ++n ) {
        // set the coordinate/time using the offset passed to this method
        f.coord(n) = origin + n*dt;
        // invert for all variables in the mesh at the same time
        DenseVector<D_complex> vars( nVars, 0.0 );
        for (  std::size_t k = 0; k < N; ++k ) {
          vars += ft.get_nodes_vars(k)*exp(+I*Wn*double(k*n));
        }
        // the dt factor is for consistency with continuous FT integral
        f.set_nodes_vars(n,vars/(N*dt));
      }
      return f;
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), f, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nnodes(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nodes_vars(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nvars().

Referenced by idft_with_ishift(), and main().

idft_with_ishift() [1/2]

OneD_Node_Mesh< D_complex > CppNoddy::FT::idft_with_ishift	(	const OneD_Node_Mesh< D_complex > &	ft,
		double	origin = 0
	)

A wrapper that calls the 'ishift' method above followed by the 'idft' method.

Parameters

ft	The frequency spectrum in the (unshifted) format.
origin	The position of the first data point returned.

Returns

The inversion data (origin+x_i, f_i).

Definition at line 68 of file FT.cpp.

                                                                                                     {
      return idft(ishift(ft),origin);
    }

References idft(), and ishift().

Referenced by idft_with_ishift(), and main().

idft_with_ishift() [2/2]

TwoD_Node_Mesh< D_complex > CppNoddy::FT::idft_with_ishift	(	const TwoD_Node_Mesh< D_complex > &	ft,
		double	origin = 0
	)

Definition at line 72 of file FT.cpp.

                                                                                                    {
      // assume that we idft each ft(.,node)
      unsigned ny = ft.get_nnodes().second;
      unsigned nx = ft.get_nnodes().first;      
      TwoD_Node_Mesh<D_complex> soln( ft.xnodes(), ft.ynodes(), ft.get_nvars());
      for ( unsigned jy = 0; jy < ny; ++jy ) {
        OneD_Node_Mesh<D_complex> ftmesh = ft.get_xsection_at_ynode(jy);
        OneD_Node_Mesh<D_complex> mesh = FT::idft_with_ishift(ftmesh,origin);
        for ( unsigned jx = 0; jx < nx; ++jx ) {
          soln.xcoord(jx)=mesh.coord(jx);
          soln.set_nodes_vars( jx, jy, mesh.get_nodes_vars(jx) );
        }
      }
      return soln;
    }

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), CppNoddy::TwoD_Node_Mesh< _Type >::get_nnodes(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nodes_vars(), CppNoddy::TwoD_Node_Mesh< _Type >::get_nvars(), CppNoddy::TwoD_Node_Mesh< _Type >::get_xsection_at_ynode(), idft_with_ishift(), CppNoddy::TwoD_Node_Mesh< _Type >::set_nodes_vars(), CppNoddy::TwoD_Node_Mesh< _Type >::xcoord(), CppNoddy::TwoD_Node_Mesh< _Type >::xnodes(), and CppNoddy::TwoD_Node_Mesh< _Type >::ynodes().

ishift()

OneD_Node_Mesh< D_complex > CppNoddy::FT::ishift

(

const OneD_Node_Mesh< D_complex > &

ft

)

Invert the shif operation to recover a spectrum in the form that is expected by the idft routine.

Parameters

ft	A previously shifted frequency spectrum.

Returns

The frequency spectrum in the (unshifted) format. 0,domega,...,(N/2)*domega, (N/2+1)*domega,...,(N-1)*domega.

Definition at line 31 of file FT.cpp.

                                                                            {
      OneD_Node_Mesh<D_complex> ft_ishifted( ft );
      double df = ft.coord(1)-ft.coord(0);
      std::size_t N = ft.get_nnodes();
      for ( std::size_t i = 0; i < N/2; ++i ) {
        for ( std::size_t var = 0; var < ft.get_nvars(); ++var ) {
          // first half of shifted output
          ft_ishifted( i, var ) = ft( N/2 + i, var );
          // second half of shifted output
          ft_ishifted( N/2 + i, var ) = ft( i, var );
        }
        ft_ishifted.coord( i ) = ft.coord( N/2 + i );
        ft_ishifted.coord( N/2 + i ) = ft.coord(N-1) + i*df;
      }
      return ft_ishifted;
    }        

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nnodes(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nvars().

Referenced by idft_with_ishift().

shift()

OneD_Node_Mesh< D_complex > CppNoddy::FT::shift

(

const OneD_Node_Mesh< D_complex > &

ft

)

Shift the frequency spectrum obtained from dft to give positive and negative freq.

Note: input should have an even number of nodes.

Parameters

ft	The frequency spectrum in the (unshifted) format.

Returns

The frequency spectrum in the (shifted) format. -(N/2)domega,...,-domega,0,domega,...,(N/2-1)*domega

Definition at line 15 of file FT.cpp.

                                                                           {
      OneD_Node_Mesh<D_complex> ft_shifted( ft );
      std::size_t N = ft.get_nnodes();
      for ( std::size_t i = 0; i < N/2; ++i ) {
        for ( std::size_t var = 0; var < ft.get_nvars(); ++var ) {
          // first half of shifted output
          ft_shifted( i, var ) = ft( N/2+i, var );
          // second half of shifted output
          ft_shifted( N/2 + i, var ) = ft( i, var );
        }
        ft_shifted.coord( i ) = -ft.coord( N/2 - i );
        ft_shifted.coord( N/2 + i ) = ft.coord( i );
      }
      return ft_shifted;
    }    

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::coord(), CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nnodes(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nvars().

Referenced by dft_with_shift(), and main().