生成用余弦调制的正弦波

Question

For research purposes, I'm trying to recreate the following (note I'm new to signal processing):

A sleep spindle is defined by a sine wave which length is longer than 500 msec and whose frequency is within the band 12 to 14 Hz. The sleep spindle template was therefore defined by a 13 Hz sine wave modulated with a cosine (in which the 1/2 period is the length of the template). The length of the template was set to 1 second. This defines a band-pass filter centred on 13 Hz.

Citation: Poiseau, E. & Jobert, M. (1991). Matched filtering applied to the detection of spindles and k-complexes in sleep eeg. http://documents.irevues.inist.fr/bitstream/handle/2042/11699/AR2_30.pdf?...1

An example of what this is supposed to look like is in Figure 1 of the above paper. I've included a cut-out of the figure below: Sleep Spindle

Here's some code that I have so far. This just creates the sine wave:

import numpy as np
import matplotlib.pyplot as plt

def sleep_spindle_match(sampling_freq):
    freq = 13 #Hz

    x = np.arange(0,1,1.0/sampling_freq)
    sine = np.sin(2 * np.pi * freq * x + (np.pi/2))

    spindle = {'x':x, 'sine':sine}

    return spindle



x = sleep_spindle_match(44100)
plt.plot(x['x'], x['sine'])
plt.show()

However, I have no clue what the "modulated with a cosine" means or how to go about implementing that. Any help in explaining this in semi-lamens terms would be much appreciated.

My ultimate goal (beyond this) is to create a match filter with the above as the template. That's a whole other story though.

Answer 1

They are speaking about (amplitude) modulation . A modulation is process of low frequency (slow) changes that happen to a high frequency signal. The former is called information signal and the latter is called carrier signal .

Looking at your picture it becomes clear that they want a high frequency sine wave to have its amplitude modulated (slowly changed over time) by a cosine wave.

So, the modulated signal will be just a sine wave with the amplitude being a cosine function:

def get_signal_func(carrier_freq, carrier_phase0, signal_freq, signal_phase0):
    def signal(x):
        amplitude = math.cos(signal_freq*x + signal_phase0)
        return apmlitude * math.sin(carrier_freq*x + carrier_phase0)
    return signal

Probably that's how it will look in numpy (example):

signal = np.cos(freq*x + (np.pi/2)) * np.sin(100*freq*x + (np.pi/2))

Please note that the sine frequency is 100 times greater than cosine one - carrier usually has higher frequency, because if a carrier and a modulator have similar frequencies, it would be difficult for receiver to reconstruct an information (cosine wave in your case).

Answer 2

My reading is that the 13Hz sine wave is scaled by a 0.5Hz cosine wave, given a 1s x axis. Just multiply the samples.

import numpy as np
import matplotlib.pyplot as plt

def sleep_spindle_match(sampling_freq):
    freq = 13 #Hz

    x = np.arange(0,1,1.0/sampling_freq)
    y = np.sin(2 * np.pi * freq * x + (np.pi/2)) * np.cos(np.pi * x + (np.pi/2))

    spindle = {'x':x, 'y':y}

    return spindle



x = sleep_spindle_match(44100)
plt.plot(x['x'], x['y'])
plt.show()