Record

Pandas- DataFrame.loc & .iloc

bangboo__ — Wed, 23 Sep 2026 13:35:15 +0900

판다스에서 많이 사용하는 DataFrame.loc, DataFrame.iloc

둘의 차이는 '무엇'을 기준으로 행/열을 찾느냐

pandas.DataFrame.loc

loc의 경우 .index/column 의 이름을 찾는다.

import pandas as pd

df = pd.DataFrame(
    {
        "name": ["A", "B", "C", "D"],
        "score": [80, 90, 70, 95]
    },
    index=[10, 20, 30, 40]
)

print(df)

>>>
   name  score
10    A     80
20    B     90
30    C     70
40    D     95

df.loc[20]

>>>
name      B
score    90

# index label 이 20인 행을 찾음.

df.loc[20:30]

>>>
   name  score
20    B     90
30    C     70
# .loc의 slicing의 경우 양 끝값 포함

df.loc[20, "score"]

>>>
90

# index가 20인 행이거니 column이 socre인 열 출력

pandas.DataFrame.iloc

iloc 의 경우 실제 위치를 찾는다.

import pandas as pd

df = pd.DataFrame(
    {
        "name": ["A", "B", "C", "D"],
        "score": [80, 90, 70, 95]
    },
    index=[10, 20, 30, 40]
)

print(df)

>>>
   name  score
10    A     80
20    B     90
30    C     70
40    D     95

df.iloc[1] # 두번쨰 행
>>>
name      B
score    90

# 여기서 1은 index label이 아니라 0부터 세었을때 1번 위치 즉 2번째 행

df.iloc[1, 1] #두번째 행, 두번째 열 
>>>
90

#########################################################
           column position
              0       1
           name    score
position 0   A       80      <- index label 10
position 1   B       90      <- index label 20
position 2   C       70      <- index label 30
position 3   D       95      <- index label 40
##########################################################

따라서 아래와 같은경우 loc 과 iloc이 같은 값 반환

df.loc[20, "score"]
>>> 90
df.iloc[1, 1]
>>> 90

loc과는 다르게 iloc의 경우 python의 일반적인 slicing 규칙을 따름.

df.iloc[1:3]
>>>
   name  score
20    B     90
30    C     70

Boolean 을 이용한 loc

import pandas as pd

df = pd.DataFrame(
    {
        "name": ["A", "B", "C", "D"],
        "score": [80, 90, 70, 95]
    },
    index=[10, 20, 30, 40]
)

print(df)

>>>
   name  score
10    A     80
20    B     90
30    C     70
40    D     95

# 먼저 
df["score"] > 80
>>>
10    False
20     True
30    False
40     True
Name: score, dtype: bool

df.loc[df["score"] > 80]
>>>
   name  score
20    B     90
40    D     95

obspy.signal.cross_correlation.correlate_template

bangboo__ — Wed, 9 Sep 2026 14:27:55 +0900

obsp.signal의 correlate 함수와는 다른 목적으로 쓰임.

2026.09.09 - [Python/obpsy] - obspy.signal.cross_correlation.correlate

obspy.signal.cross_correlation.correlate

더보기 """ Cross-correlation of two signals up to a specified maximal shift. This function only allows 'naive' normalization with the overall standard deviations. This is a reasonable approximation for signals of similar length and a relatively small sh

5daeng.tistory.com

correlate(a,b, shift) ---- 두 비슷한 길이의 신호사이의 상대 shift 찾기 (b가 a에 비해 몇 sample 이동했나?)

correlate_template(data, template) ---- 긴 data안에서 짧은 template이 어디에 있는지 찾기 (이 template이 data에 어디에 있나?)

correlate_template은 shift를 지정하지 않고, template이 data의 전체위에서 움직인다.

data
------------------------------------------------------------

template
██████

가능한 위치:

██████
  ██████
    ██████
      ██████
         ...
                              ██████

def _window_sum(data, window_len):
    """Rolling sum of data."""
    window_sum = np.cumsum(data)
    # in-place equivalent of
    # window_sum = window_sum[window_len:] - window_sum[:-window_len]
    # return window_sum
    np.subtract(window_sum[window_len:], window_sum[:-window_len],
                out=window_sum[:-window_len])
    return window_sum[:-window_len]

def correlate_template(data, template, mode='valid', normalize='full',
                       demean=True, method='auto'):
    # if we get Trace objects, use their data arrays
    if isinstance(data, Trace):
        data = data.data
    if isinstance(template, Trace):
        template = template.data
    data = np.asarray(data)
    template = np.asarray(template)
    lent = len(template)
    if len(data) < lent:
        raise ValueError('Data must not be shorter than template.')
    if demean:
        template = template - np.mean(template)
        if normalize != 'full':
            data = data - np.mean(data)
            
            
    cc = scipy.signal.correlate(data, template, mode=mode, method=method)
    if normalize is not None:
        tnorm = np.sum(template ** 2)
        if normalize == 'naive':
            norm = (tnorm * np.sum(data ** 2)) ** 0.5
            if norm <= np.finfo(float).eps:
                cc[:] = 0
            elif cc.dtype == float:
                cc /= norm
            else:
                cc = cc / norm
        elif normalize == 'full':
            pad = len(cc) - len(data) + lent
            if mode == 'same':
                pad1, pad2 = (pad + 2) // 2, (pad - 1) // 2
            else:
                pad1, pad2 = (pad + 1) // 2, pad // 2
            data = _pad_zeros(data, pad1, pad2)
            # in-place equivalent of
            # if demean:
            #     norm = ((_window_sum(data ** 2, lent) -
            #              _window_sum(data, lent) ** 2 / lent) * tnorm) ** 0.5
            # else:
            #      norm = (_window_sum(data ** 2, lent) * tnorm) ** 0.5
            # cc = cc / norm
            if demean:
                norm = _window_sum(data, lent) ** 2
                if norm.dtype == float:
                    norm /= lent
                else:
                    norm = norm / lent
                np.subtract(_window_sum(data ** 2, lent), norm, out=norm)
            else:
                norm = _window_sum(data ** 2, lent)
            norm *= tnorm
            if norm.dtype == float:
                np.sqrt(norm, out=norm)
            else:
                norm = np.sqrt(norm)
            mask = norm <= np.finfo(float).eps
            if cc.dtype == float:
                cc[~mask] /= norm[~mask]
            else:
                cc = cc / norm
            cc[mask] = 0
        else:
            msg = "normalize has to be one of (None, 'naive', 'full')"
            raise ValueError(msg)
    return cc

따라서 mode='valid' 인것이 합리적이고 당연하고 실제로 default 값이다. 당연히 template의 길이가 data 보다 짧아야한다.

예를 들어서.

data length     = 1000
template length = 100

#mode='valid'의 결과 길이는 1000-1000+1 = 901

cc[0]은 template와 data[0:100]의 비교 결과
cc[1]은 template와 data[1:101]의 비교 결과
cc[450]은 template와 data[450:550]의 비교결과

Normalization (full)

각 template 위치마다 data window의 normalization을 새로 계산

그래서 full normalization은 위치마다 denominator가 다르다. 따라서 진폭이 달라도 shape가 같으면 cc=1이 될 수 있다.

obspy.signal.cross_correlation.correlate

bangboo__ — Wed, 9 Sep 2026 13:20:15 +0900

    """
    Cross-correlation of two signals up to a specified maximal shift.

    This function only allows 'naive' normalization with the overall
    standard deviations. This is a reasonable approximation for signals of
    similar length and a relatively small shift parameter
    (e.g. noise cross-correlation).
    If you are interested in the full cross-correlation function better use
    :func:`~obspy.signal.cross_correlation.correlate_template` which also
    provides correct normalization.

    :type a: :class:`~numpy.ndarray`, :class:`~obspy.core.trace.Trace`
    :param a: first signal
    :type b: :class:`~numpy.ndarray`, :class:`~obspy.core.trace.Trace`
    :param b: second signal to correlate with first signal
    :param int shift: Number of samples to shift for cross correlation.
        The cross-correlation will consist of ``2*shift+1`` or
        ``2*shift`` samples. The sample with zero shift will be in the middle.
    :param bool demean: Demean data beforehand.
    :param normalize: Method for normalization of cross-correlation.
        One of ``'naive'`` or ``None``
        (``True`` and ``False`` are supported for backwards compatibility).
        ``'naive'`` normalizes by the overall standard deviation.
        ``None`` does not normalize.
    :param str method: Method to use to calculate the correlation.
         ``'direct'``: The correlation is determined directly from sums,
         the definition of correlation.
         ``'fft'`` The Fast Fourier Transform is used to perform the
         correlation more quickly.
         ``'auto'`` Automatically chooses direct or Fourier method based on an
         estimate of which is faster. (Only availlable for SciPy versions >=
         0.19. For older Scipy version method defaults to ``'fft'``.)

    :return: cross-correlation function.

    To calculate shift and value of the maximum of the returned
    cross-correlation function use
    :func:`~obspy.signal.cross_correlation.xcorr_max`.

    .. note::

        For most input parameters cross-correlation using the FFT is much
        faster.
        Only for small values of ``shift`` (approximately less than 100)
        direct time domain cross-correlation migth save some time.

    .. note::

        If the signals have different length, they will be aligned around
        their middle. The sample with zero shift in the cross-correlation
        function corresponds to this correlation:

        ::

            --aaaa--
            bbbbbbbb

        For odd ``len(a)-len(b)`` the cross-correlation function will
        consist of only ``2*shift`` samples because a shift of 0
        corresponds to the middle between two samples.
    """

###helper

def _pad_zeros(a, num, num2=None):
    """Pad num zeros at both sides of array a"""
    if num2 is None:
        num2 = num
    hstack = [np.zeros(num, dtype=a.dtype), a, np.zeros(num2, dtype=a.dtype)]
    return np.hstack(hstack)

##################################################################################

def _xcorr_padzeros(a, b, shift, method):
    """
    Cross-correlation using SciPy with mode='valid' and precedent zero padding.
    """
    if shift is None:
        shift = (len(a) + len(b) - 1) // 2
    dif = len(a) - len(b) - 2 * shift
    if dif > 0:
        b = _pad_zeros(b, dif // 2)
    else:
        a = _pad_zeros(a, -dif // 2)
    return scipy.signal.correlate(a, b, mode='valid', method=method)
    
##################################################################################

def _xcorr_slice(a, b, shift, method):
    """
    Cross-correlation using SciPy with mode='full' and subsequent slicing.
    """
    mid = (len(a) + len(b) - 1) // 2
    if shift is None:
        shift = mid
    if shift > mid:
        # Such a large shift is not possible without zero padding
        return _xcorr_padzeros(a, b, shift, method)
    cc = scipy.signal.correlate(a, b, mode='full', method=method)
    return cc[mid - shift:mid + shift + len(cc) % 2]
    
##################################################################################
##################################################################################

### main

def correlate(a, b, shift, demean=True, normalize='naive', method='auto'):
  
    if normalize is False:
        normalize = None
    if normalize is True:
        normalize = 'naive'
    # if we get Trace objects, use their data arrays
    if isinstance(a, Trace):
        a = a.data
    if isinstance(b, Trace):
        b = b.data
    a = np.asarray(a)
    b = np.asarray(b)
    if demean:
        a = a - np.mean(a)
        b = b - np.mean(b)
        
    # choose the usually faster xcorr function for each method
    
    _xcorr = _xcorr_padzeros if method == 'direct' else _xcorr_slice
    cc = _xcorr(a, b, shift, method)
    
    if normalize == 'naive':
        norm = (np.sum(a ** 2) * np.sum(b ** 2)) ** 0.5
        if norm <= np.finfo(float).eps:
            # norm is zero
            # => cross-correlation function will have only zeros
            cc[:] = 0
        elif cc.dtype == float:
            cc /= norm
        else:
            cc = cc / norm
    elif normalize is not None:
        raise ValueError("normalize has to be one of (None, 'naive'))")
    return cc

obpsy correlation은 scipy이 correlate 함수를 쓴다.

참고

2026.09.09 - [Python/Scipy] - scipy.signal.correlate

scipy.signal.correlate

scipy.signal.correlatehttps://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.correlate.html#scipy.signal.correlate>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> sig =

5daeng.tistory.com

obspy correlate의 작동방식을 보면,

먼저 전체적인 파이프라인은 아래와 같음

입력 a,b
Trace면 .data 추출 및 demean
method에 따라 계산 방식 선택 (direct, fft, auto)
원하는 ±shift 구간의 cross-correlation 계산 및 normalization
return cc

method	obspy 함수	scipy mode
'direct'	_xcorr_padzeros()	'valid'
'fft'	_xcorr_slice()	'full'
'auto'	_xcorr_slice()	'full'

_xcorr_slice()

full cross correlation을 계산하고 slice(사용자 지정 shift 만큼)

def _xcorr_slice(a, b, shift, method):

    mid = (len(a) + len(b) - 1) // 2

    if shift is None:
        shift = mid

    if shift > mid:
        return _xcorr_padzeros(a, b, shift, method)

    cc = scipy.signal.correlate(
        a,
        b,
        mode='full',
        method=method
    )

    return cc[
        mid - shift:
        mid + shift + len(cc) % 2
    ]

scipy.correlate을 이용해서 full correlation(lag에 대한 correlation 계산)을 계산한 후 그 간운데 ±shift만 잘라냄.

예시,

len(a) = 1001
len(b) = 1001

# full correlation length : 1001+1001−1=2001


mid = 2001 // 2
    = 1000
    
# full CC index 

index:
0 -------------------------------- 1000 -------------------------------- 2000

lag:
-1000 ----------------------------- 0 -------------------------------- +1000
                                      ↑
                                     mid
                                     
shift = 100 이라고 지정해주면

전체 full correlation

-1000 ================================================ +1000
                         |-----------|
                           ObsPy 반환
                          -100 ~ +100 sample
                          
                          
## ouput length : 2xshift + 1

참고 lag=0 은 두 배열이 첫항부터 정렬되었을때를 말함. 아래 참고

lag = -500

b: b0 ... b500
                ↓
a:              a0 a1 ... a1000

딱 1 sample 겹침


a: a0 a1 a2 ... a500 ... a1000
b: b0 b1 b2 ... b500
   ↑  ↑  ↑       ↑

a[0]과 b[0]이 맞음

lag = +500

a: a0 ... a500 ... a1000
             ↑
b:           b0 ... b500

이때 b가 a 안쪽 뒤쪽에 위치

lag = +1000

a: a0 ....................... a1000
                              ↑
b:                            b0 ... b500

딱 1 sample 겹침

_xcorr_padzeros()

valid mode의 결과 길이가 정확하게 원하는 2*shift + 1 정도가 되도록 두 신호 중 하나를 zero padding한다.

def _xcorr_padzeros(a, b, shift, method):

    if shift is None:
        shift = (len(a) + len(b) - 1) // 2

    dif = len(a) - len(b) - 2 * shift

    if dif > 0:
        b = _pad_zeros(b, dif // 2)
    else:
        a = _pad_zeros(a, -dif // 2)

    return scipy.signal.correlate(
        a,
        b,
        mode='valid',
        method=method
    )

normalize='naive'

norm = (
    np.sum(a ** 2) *
    np.sum(b ** 2)
) ** 0.5


cc /= norm

따라서 아래와 같은 pipeline으로 진행

cc = correlate(
    a,
    b,
    shift=100,
    demean=True,
    normalize='naive',
    method='auto'
)

correlate()
   │
   ├─ a,b numpy array 변환
   │
   ├─ mean 제거
   │
   │    a -= mean(a)
   │    b -= mean(b)
   │
   ├─ method != 'direct'
   │
   └─ _xcorr_slice()
          │
          ├─ signal.correlate(
          │      a,
          │      b,
          │      mode='full',
          │      method='auto'
          │   )
          │
          │        ↓
          │   SciPy가 direct / fft 선택
          │
          └─ ±100 samples slice

         ↓

normalize

         ↓

201개 CC 반환

scipy.signal.correlate

bangboo__ — Wed, 9 Sep 2026 12:36:55 +0900

scipy.signal.correlate

https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.correlate.html#scipy.signal.correlate

correlate — SciPy v1.18.0 Manual

Implement a matched filter using cross-correlation, to recover a signal that has passed through a noisy channel. >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> sig = np.repeat([

docs.scipy.org

correlate(in1, in2, mode='full', method='auto')

2개의 N-dimensinal array를 교차상관한다. mode에 따라서 output size가 결정됨.

in1, in2 : 두 input의 차원은 같아야함
mode= 'full'
- 부분적으로 1 sample만 겹치는 경우까지 전부 포함
- 개념적으로 y를 x 위에서 왼쪽 끝부터 오른쪽 끝까지 쭉 움직이면서 correlation을 계산
- 따라서 만약 len(in1)=N, len(in2)=M 이면 len(output)=N+M-1
- 따라서 모든 lag에 대한 correlation 정도를 알 수 있음.
- 만약 모든 lag에 대해서 조사를 하고 lag를 제한을 두면 효과적으로 사용 가능

max_lag_sec = 2.0
max_lag_sample = int(max_lag_sec / dt)

mask = np.abs(lags) <= max_lag_sample

corr_search = corr[mask]
lags_search = lags[mask]

idx = np.argmax(corr_search)

best_lag = lags_search[idx]

mode = 'same'
- mode='full' correlation의 중앙 부분만 잘라서 반환 이때 output의 길이는 in1이랑 같게
- len(output) = len(in1)

len(master), len(slave)
>>> 1000,1000

##full

signal.correlate(master, slave, mode='full')

lag
-999 ---------------- 0 ---------------- +999

       가능한 모든 shift를 계산
       
       
       
##same

signal.correlate(master, slave, mode='same')

FULL

-999 ---------------- 0 ---------------- +999
          |<------ SAME ------>|

mode = 'valid'
- 한 신호가 다른 신호 안에 완전히 들어와 있을 때만 correlation을 계산
- 출력길이는 N-M+1
- template matching에 유용함
- template이 trace 밖으로 삐져나가는 위치는 아예 계산하지 않으므로
  - "template 전체가 trace에 존재하는 위치에서만 비교하겠다"

그림으로 비교하면

len(in1)
>>> 5
len(in2)
>>> 3


##full
       x x x x x
y y y
  y y y
    y y y
      y y y
        y y y
          y y y
            y y y

총 7 positions

##same
       x x x x x
    y y y
      y y y
        y y y
          y y y
            y y y

총 5 positions


##valid 
       x x x x x

       y y y
         y y y
           y y y

총 3 positions

method
- direct
  - time domain에서 직접 수행(시그마 직접 계산)
  - C[k]=n∑x[n]y[n−k]
- fft
  - freq. domain에서 두 spectrum을 곱하고 다시 IFFT
- auto
  - scipy가 직접 판단 (신호길이에 따라 direct와 auto의 계산 효율 차이가 많이 나기 때문)

Pandas- DataFrame.duplicated()

bangboo__ — Wed, 26 Aug 2026 09:37:30 +0900

https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.duplicated.html#pandas.DataFrame.duplicated

pandas.DataFrame.duplicated — pandas 3.0.5 documentation

Only consider certain columns for identifying duplicates, by default use all of the columns.

pandas.pydata.org

DataFrame.duplicated(subset=None, keep='first')

duplicated() -> 중복된 행(데이터)를 찾아서 Boolean(True/False)로 반환

Option
- subset = 특정 열(columns)만 이용 , default = all column
- keep
  - ='first' : 중복된 값 증 처음 등장한 값 : False 그 뒤로는 True
  - ='last' : 중복된 값 중 마직막 등장 값 : False 그 앞으로는 True
  - =False : 중복이 발생한 값의 모든 위치를 True

예시]

import pandas as pd

s = pd.Series([0.0, 1215.0, 1215.0, 3480.0, 3480.0, 6371.0])

# 1. 기본값 (keep='first') -> 두 번째로 나온 중복값만 True
print(s.duplicated())
# 결과: [False, False, True, False, True, False]

# 2. keep=False -> 중복된 값 전체를 True로 선택
print(s.duplicated(keep=False))
# 결과: [False, True, True, True, True, False]

# 3. 중복된 고유 반경값만 추출
print(s[s.duplicated(keep=False)].unique())
# 결과: array([1215., 3480.])

SAC HEADER

bangboo__ — Sun, 23 Aug 2026 14:14:33 +0900

NPTS = number of data points

B = begin time
E = end time

IFTYPE = file type
LEVEN = evenly sampled time series
DELTA = spacing in time of data points
IDEP = physical unit of the data

DEPMIN = minimum amplitude
DEPMAX = maximum amplitude
DEPMEN = mean amplitude

OMARKER = event origin marker
AMARKER = first arrival (P) marker
T0MARKER = t0 (S) marker

KZDATE = reference date
KZTIME = reference time
IZTYPE = type of reference time

KSTNM = station name
CMPAZ = component azimuth relative to north
CMPINC = component "incidence angle" reletive to the vertical
STLA = station latitude
STLO = station longitude
STEL = station elevation
STDP = station depth below surface (meters)

EVLA = event latitude
EVLO = event longitude
EVDP = event depth

DIST = source receiver distance in km
AZ = azimuth
BAZ = back azimuth
GCARC = great circle distance

LOVROK = TRUE if it is okay to overwrite this file on disk
NVHDR = Header version number. Current value is the integer 6.
SCALE = Multiplying scale factor for dependent variable
NORID = Origin ID (CSS 3.0)
NEVID = Event ID (CSS 3.0)
NWFID = Waveform ID (CSS 3.0)
LPSPOL = TRUE if station components have a positive polarity (left-hand rule)
LCALDA = TRUE if DIST, AZ, BAZ, and GCARC are to be calculated from station and event coordinates
KCMPNM = Component name
KNETWK = Network name
MAG = Event magnitude

Linear systems - Convolution and Deconvolution modeling

bangboo__ — Fri, 22 May 2026 23:33:30 +0900

1. Convolution

Ai generated

Linear system으로의 해석의 장점은 complicated physical effect(multiple linear system)도 쉽게 일반화할 수 있다는 점이다.

만약 신호 $x(t)$가 두개의 linear system을 지나간다고 생각해 보자.

net output in time domain은 아래와 같다.

$$y(t) = x(t) * f(t) * g(t)$$

frequency domain에서는

$$Y(\omega)=X (\omega)F (\omega)G (\omega)$$

이다.

Seismogram도 위와 같이 일반화 할 수 있다.

$x(t)$ 는 source signal, $g(t)$는 response of operator representing the effects of earth structure along ray path, $i(t)$는 impulse response of seismometer

$$u(t) = x(t) *g(t)*i(t)$$

종종 Impulse response는 시간과 공간에서 모두 정의 되기도 한다. 시간 $t$일때, 어떤 한지점 $\mathbf{x}$ 에서의 변위는 다음과 같이 나타낼 수 있다.

$$ u(\mathbf{x} ,t) = \iint G(\mathbf{x-x'} ; t-t') f(\mathbf{x'},t') dt'dV'~~~\text{laterally homogeneous medium} $$

$G$를 green function 이라고 부른다. 그린함수는 position $\mathbf{x}$, time $t'$에서의 impulse response로 생각할수 있으며, $ f(\mathbf{x'},t') $는 seismic source의 분포로 생각할 수 있다. 따라서 이를 sum한 (integral) 결과는 source의 distribution의 total response로 생각할 수 있다.

또 위 식은 laterally homogeneous medium을 가정한 경우로, 그린함수의 변수는 source와 receiver의 거리 ($\mathbf{x} - \mathbf{x}'$) 에만 의존한다. 따라서 convolution의 형태를 갖추는 것을 관찰할 수 있다.

하지만 실제 일반 매질은 관측소의 위치( $\mathbf{x}$) 지진원의 절대 위치($\mathbf{x}'$) 가 변수이다. 아래와 같이 식이 변하고,

$$u(\mathbf{x}, t) = \iint G(\mathbf{x}, t; \mathbf{x}', t') f(\mathbf{x}', t') dt' dV'$$

변위는 지진원 분포($f$)에 각 위치마다 다르게 적용되는 가중치 ($G$)를 곱해서 더한 결과가 displacement가 된다.

2. Deconvolution

System이 convolution을 통해 표현될때, 우리는 system에 영향을 주는 factor들을 deconvolution을 통해 알아 낼 수 있다.

$s(t)$ : seismogram result form convolution of source

$w(t)$ : source pulse or wavelet

$r(t)$ : earth structure operator ( reflector series) delta 함수의 series로 생각 할 수 있다. 마치interface로 부터 reflect되어 도착하는 arrival time이 delta function의 위치라고 생각할 수 있다.

그림과 같이 지진파형은 아래와 같이 나타낼 수 있다.

$$ s(t) = w(t) * r(t) ~\text{and}~S(\omega) = W( \omega)R( \omega) $$

현실에서는 source pusle ($w(t)$)는 어느정도의 두께(time duration)을 가지고 있다. 따라서 만약 반사계수열($r(t)$)이 인접해있다면, 두 층에서의 convolution 결과가 서로 overlap 될 것이다.

만약 source pulse가 ideal한 delta function이라면 time domain에서의 convolution은 주파수 영역에서의 multiplication이고 delta function의 FT는 1인 상수 값이므로, 이때 결과 지진파형은 r(t)과 같아진다.

하지만 실제 자연의 source pulse는 delta function 이아니다. 그러면, Inverse filter를 도입하면 어떨까?

신호의 관점에서 컨벌루션(convolution) 과정은 주파수 영역에서 다음과 같이 표현됩니다.

$$S(\omega) = W(\omega) R(\omega)$$

여기서 역필터(inverse filter) $W^{-1}(\omega)$를 정의하면, 시간 영역에서의 델타 함수 $\delta(t)$에 대응하여 주파수 영역에서는 다음과 같은 관계가 성립합니다.

$$W^{-1}(\omega) W(\omega) = 1 \implies W^{-1}(\omega) = \frac{1}{W(\omega)}$$

따라서, 원본 신호 $R(\omega)$를 복원하는 과정은 다음과 같습니다.

$$R(\omega) = \frac{S(\omega)}{W(\omega)}$$

문제점 및 해결 방안

위의 나눗셈 과정에서 $W(\omega)$의 값이 0에 가깝게 매우 작아지면, $R(\omega)$가 무한대로 발산하는 노이즈 증폭 현상이 발생합니다. 이를 방지하기 위해 최소 진폭(water level)을 설정하는 기법이 필수적입니다.

이를 수식으로 표현하면 다음과 같습니다.

$$R(\omega) = \frac{S(\omega) \cdot W^*(\omega)}{|W(\omega)|^2 + \epsilon}$$

여기서 $W^*(\omega)$는 $W(\omega)$의 켤레 복소수입니다.
$\epsilon$은 Water level이라 불리는 작은 상수값으로, 분모가 0이 되는 것을 방지하여 안정성을 확보합니다.

Vespagram - Intro

bangboo__ — Thu, 21 May 2026 16:02:52 +0900

1. Basic Theory

핵심 내용은 Slant stacking , Beam forming이라고 할 수 있음.

여러 지진계에서 기록된 waveform을 특정 방위각(back azimuth)또는 slowness(or rayparameter)에 맞추어 arrival time difference를 보정해서 stacking하는 방식

1-1. 핵심 물리량

Slowness (or ray parameter)
- 속도의 역수, 지진파 wavefornt의 겉보기 속도의 역수, ray incidence angle과 직접적인 연관이 있음
- unit : s/deg or s/km
BAZ(back-azimuth)
- 관측소(array)에서 지진원(epicenter)를 바라보는 방향각

1-2. 수학적 원리

reference station 으로부터 각 관측소 $i$ 까지의 상대적 위치벡터를 $\mathbf(r_i)$, 탐색하고자 하는 slowness vector를 $\mathbf{u}$ 라 할 때, time shift $\Delta t_i$ 는 다음과 같다.

$$\Delta t_i = \mathbf{u} \cdot \mathbf{r}_i$$

각 관측소에서 관측된 파형 $f_i(t)$를 time shift $\Delta t_i$ 만큼 이동시켜 합산(stacking)하면 beam waveform $S(u, t)$ 가 생성

$$S(u, t) = \frac{1}{N} \sum_{i=1}^{Filter} f_i(t - \Delta t_i)$$

Linear stack : 그대로 평균
Nth root stack : 신호의 부호를 유지한 채 $N$제곱근을 취해 더한 뒤 다시 $N$제곱을 하여, 가간성(Coherence)이 낮은 무작위 배경 잡음을 획기적으로 억제

2. Application

지구 심부 연구 (내/외핵, 맨틀)
- 핵-맨틀 경계면(CMB) 및 내핵 연구: PKP, PcP, PKiKP 등 지구 심부를 통과하거나 외핵-내핵 경계면에서 반사된 위상들은 에너지가 매우 약합니다. 베스파그램을 통해 특정 내부 슬로우니스를 가진 신호만 증폭
- 맨틀 불연속성 탐지: 상부 맨틀 및 전이대 불연속면($410\text{ km}$, $660\text{ km}$)의 상하면 반사파(Underside reflections, e.g., PP 또는 SS 전구체 위상)를 검
위상 식별 및 도달 시간 측정
- 지진동이 시작된 후 수많은 파가 겹쳐서 들어오는 코다(Coda) 구간 내에서, 이론적 도달 시간 모델(ak135, iasp91 등)과 실제 관측된 슬로우니스-시간 쌍을 대조하여 정확히 어떤 물리적 위상(Phase picker)인지 명확하게 구분
지진원 및 산란원 추적 (Source & Scatterer Location)
- 지진파가 들어온 역방향(BAZ)과 입사각을 역산하여 지진원의 위치를 추적합니다. 또한 불균질한 매질에 의해 꺾여 들어오는 산란파(Scattered waves)의 기원지를 찾음

Linear systems - Basic model and Filter

bangboo__ — Tue, 19 May 2026 00:48:06 +0900

Fourier analysis는 지진학에서 지진계에 작동하는 여러 factor들을 modeling하는데에 유용하게 쓰인다.

지진계는 ground motion을 '그대로' 기록하지 못한다. 지진계 자기자신으로 인한 효과도 같이 지진계에 기록된다. 게다가 지진계를 흔드는 ground motion은 진원(seismic source), 지구의 elastic, anelastic structure 도 반영된다. 이러한 서로 다른 factor들의 combination이 우리가 보는 signal이다. 이러한 signal들을 잘 해석하기 위해서 linear system이라는 아이디어를 이용한다.

수학적으로 하나의 operator로 해석할 수 있는데, input signal을 우리가 보는 output signal로 바꿔서 보여주는 역할을 한다고 생각하면 된다.

1. Basic model

Linear system은 아래와 같이 나타낼 수있다.

$$ x_1 (t) \rightarrow y_1(t) $$

$$ X_2 (t) \rightarrow y_2(t) $$

두 신호를 combine 한 경우에도

$$ Ax_1(t) +Bx_2(t) \rightarrow Ay_1(t) + By_2(t) $$

이러한 특징을 superposition이라고 표현하기도 한다.

주목할 점은 Fourier transform도 Linearity를 만족한다는 것이다.

Linear system을 impulsive delta function에 대한 response로 생각해보자.

시스템에 시간영역에서 아주짧고 강한 impulse를 input으로 준다는 것이다.

이 impulse에 대한 resoponse 를 $f(t)$라 하자.

$$ f(t) ~:impulse~resopnse~of~system $$

이 time series의 Fourier transform이 $F(\omega)$라고 생각 할 수 있다. 이를 시스템의 전달함수[Trasnfer function]이라고 부른다.

따라서 임의의 복잡한 입력신호 $x(t)$가 이 시스템을 통과하여 출력이 만들어질때, 시간영역에서는 두 신호를 겹쳐서 적분하는 convolution 연산이 진행되어야 한다. 하지만 주파수 영역에서는 $X(\omega)$에 system transfer function $F(\omega)$를 단순히 곱하면 된다.

Input	Linear System	Output
Impulse $\delta(t)$	$ \rightarrow [ Linear system : response f(t) ] \rightarrow $	$f(t)$ : impulse response $F(\omega)$ : transfer function
Arbitary signal $x(t)$	$ \rightarrow [ Linear system : response f(t) ] \rightarrow $	$ y(t) = x(t) * f(t) $ $Y(\omega) = X( \omega)F( \omega )$
Harmonic $e^{i\omega_0 t}$	$ \rightarrow [ Linear system : response f(t) ] \rightarrow $	$F( \omega_0) e^{i\omega_0 t} $

좀 더 자세히 설명하면 전달함수는 주파수 영역 내의 시스템의 고유한 규칙이라고 볼 수 있다.

어떤 신호도 시스템에 들어오지 않은 상태라고 해보자. 이 시스템이 예를 들어 1Hz 성분은 2배증폭, 5Hz 성분은 감쇠 시키는 시스템이라고 해보자, 이처럼 입력될 주파수 성분을 어떻게 조작할 지 미리적어놓은 레시피가 같은 것이 전달함수, Transfer function$F(\omega)$이다.

이 전달함수가 시간영역에서 어떻게 생겼는지 알아보기 위해서 0.00001Hz부터 100000..000Hz까지의 모든 주파수를 가진 신호를 system에 input으로 넣어보기 보다는 $F(\omega)$에 1을 곱한 상태라고 생각해보자. 이를 역변환하여 나오는것이 impulse response,$f(t)$이다. 즉 전달함수의 역변환이라고 생각할 수 있다.

따라서 어떤 임의의 신호가 시스템을 지나간 후 출력을 아래와 같이 적을 수 있다.

$$Y(\omega)=X(\omega) F(\omega)$$

주파수 영역에서의 함수는 일반적으로 복소수이므로, 위상과 amplitude도 modifiy된다.

time domain에서의 함수는

$$y(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} X(\omega) F(\omega) e^{i\omega t} d\omega.$$

이제 input time function[$x(t)$], impulse response[$f(t)$], output timefunction[$y(t)$]에 대해 알아보자

$X(\omega)$ 와 $F(\omega)$를 transform으로 적으면,

$$y(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} \left[ \int_{-\infty}^{\infty} x(\tau) e^{-i\omega\tau} d\tau \right] \left[ \int_{-\infty}^{\infty} f(\tau') e^{-i\omega\tau'} d\tau' \right] e^{i\omega t} d\omega,$$

정리하면,

$$y(t) = \int_{-\infty}^{\infty} \int_{-\infty}^{\infty} x(\tau) f(\tau') \left[ \frac{1}{2\pi} \int_{-\infty}^{\infty} e^{i\omega(t-\tau'-\tau)} d\omega \right] d\tau d\tau'.$$

이 된다.

bracket 안의 term은 delta function의 inverse transformation 이므로,

$$\text{since,}~\frac{1}{2\pi} \int_{-\infty}^{\infty} e^{i\omega(t-\tau'-\tau)} d\omega = \delta(t - \tau' - \tau),$$

아래와 같이 적을 수 있고,

$$y(t) = \int_{-\infty}^{\infty} x(\tau) \left[ \int_{-\infty}^{\infty} f(\tau') \delta(t - \tau' - \tau) d\tau' \right] d\tau.$$

델타함수의 정의를 이용하면,

$$y(t) = \int_{-\infty}^{\infty} x(\tau) f(t - \tau) d\tau =x(t) * f(t).$$

와같이 적을 수 있다. 이것이 convolution의 정의

따라서 linear system의 ouput은 input signal과 impulse response의 convolution이라고 적을 수 있다.

즉, time domain에서의 convolution은 freqency domain에서의 multiplication이다.

$ Y(\omega)=X(\omega) F(\omega) \leftrightarrow y(t)= x(t) * f(t) $

따라서 Linear system을 아래와 같이 정리할 수 있다.

In time domain - Impulse response
- 시스템이 시간의 흐름에 따라 신호에 어떻게 반응하는지,,,
- 이때 입력신호(input)와 임펄스응답(impulse response)을 convolution하여 출력결과가 나옴
In frequency domain - transfer function
- impulse 응답을 수학적으로 변화( 푸리에 변환, 라플라스변환) 하여 주파수 관점으로 바라봄
- 입력신호의 변환과 시스템의 전달함수의 단순곱으로 출력결과 알 수 있음.

1-1. Filter

지진파 기록을 특정 주파수 대역에서만 보고 싶을 때는, bandpass filter를 사용 할 수 있다.

filtering을 하기 위해서는 frequency domain 에서 필터를 seismogram의 fourier transform을 곱하면 된다.

이후 bandpass filter가 곱해진 fourier transform of seismogram은 특정 주파수 대역만 살아남게 된다.

이후 inverse transform을 취하면 bandpass 된 결과를 볼 수 있는데 이는 사실 bandpass filter의 impulse response를 time domain에서 convolution 한것 과 같다.

몇가지 주의할 점이 있다.

일반적으로 filter를 positive frequency에서만 plot한다. 하지만, negative frequency에서도 정의되어야 한다.
- 결과 signal 이 real이여야 하기 때문
bandpass filter의 impulse response가 impulse 전부터 생기는 것을 주목
- 우너래 'impulse response'는 delta function(모든 주파수성분이 담긴)이 들어왔을 때의 time series의 반응인데, banpass filter는 특정 주파수만 담기 때문에 시간영역에 신호가 들어오기 전부터 응답이 시작되는 비인과적인 형태가 나타남.
filter의 끝부분이 sharp corner를 가짐
- smoothing을 필요로 함. 왜냐하면 gibbs phenomenon 발생 혹은 위에서 언급한 noncausal artifact가 생김.

Fourier Analysis - Delta functions

bangboo__ — Mon, 4 May 2026 05:36:55 +0900

굉장히 짧은 시간 동안 '충격'처럼 전달되는 신호를 어떻게 표현 할까?? 이런 신호를 표현하는 유명한 신호가 바로 Dirac delta function이다.

1. Definition and Properties

delta function을 정의하는 방법은 여러가지 이지만 아래와 같이 정의할 수있다.

$ t=t_0 $에서의 Delta function은,, Gaussian function의 극한으로 설명할 수 있다. Gaussian function의 넓이는 1임을 주목하자.

$$\delta(t - t_0) = \lim_{\sigma \to 0} \frac{1}{\sigma\sqrt{2\pi}} \exp \left[ \frac{-1}{2} \left( \frac{t - t_0}{\sigma} \right)^2 \right].$$

집중성
- $t = t_0$에서는 무한대의 값, 나머지는 0의 값을 가짐.
면적
- $\int_{-\infty}^{\infty} \delta(t-t_0) dt = 1$
Shifting
- $f(t_0) = \int_{-\infty}^{\infty} f(t) \delta(t - t_0) \, dt = f(t_0) \int_{-\infty}^{\infty} \delta(t - t_0) \, dt$
Relation with Step function [Heaviside function]
- delta function은 step function의 derivative

2. Fourier Transform of Delta function[in time domain]

$$f(t) = \delta(t-t_0) \iff F(\omega) = \int_{-\infty}^{\infty} \delta(t-t_0) e^{-i\omega t} \, dt = e^{-i\omega t_0}$$

$$ |F(\omega)| =1 , \phi(\omega) = -\omega t_0$$

만약 $t_0 = 0$ 이면,

$$f(t) = \delta(t) \iff F(\omega) = \int_{-\infty}^{\infty} \delta(t) e^{-i\omega t} \, dt = 1$$

따라서 delta function의 amplitude spectrum은 모든 주파수에서 1의 unit amplitude를 가짐을 알 수 있다.

inverse transform 은 아래와 같다.

$$f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} e^{-i\omega t_0} e^{i\omega t} \, d\omega = \frac{1}{2\pi} \int_{-\infty}^{\infty} e^{i\omega (t-t_0)} \, d\omega = \delta(t - t_0),$$

따라서 delta function은 모든 주파수의 sinusoid들의 합으로 생각할 수 있다.

3. Fourier Transform of Delta function [in frequency domain]

delta function at angular frequency at $\omega_0$ 는 $ \delta(\omega - \omega_0)$로 나타낼 수 있다.

time domain으로의 inverse transform은

$$f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} \delta(\omega - \omega_0) e^{i\omega t} \, d\omega = \frac{1}{2\pi} e^{i\omega_0 t}$$

time domain에서 freq domain으로의 transform은

$$\delta(\omega - \omega_0) = \frac{1}{2\pi} \int_{-\infty}^{\infty} e^{i\omega_0 t} e^{-i\omega t} \, dt = \frac{1}{2\pi} \int_{-\infty}^{\infty} e^{i(\omega_0 - \omega)t} \, dt$$

주파수가 $\omega_0$인 sinusoid들의 합으로 생각 할 수 있다.

3-1. example $f(t) = cos(\omega t_0) $

주어진 신호는.

$$f(t) = cos(\omega_0 t) = ( e^{i\omega_0 t}+ e^{-i\omega_0 t} )/ 2 $$

푸리에 변환은

$$F(\omega) = \frac{1}{2} \int_{-\infty}^{\infty} [e^{i\omega_0 t} + e^{-i\omega_0 t}] e^{-i\omega t} \, dt = \frac{1}{2} \int_{-\infty}^{\infty} [e^{i(\omega_0 - \omega)t} + e^{-i(\omega_0 + \omega)t}] \, dt.$$

오른쪽 부분은 두개의 frequency domain에서의 delta function과 같다. 따라서

$$F(\omega) = \pi [\delta(\omega - \omega_0) + \delta(\omega + \omega_0)].$$