Skip to content

Background Image

Background_Image

Source code in AIS/Background_Image/background_image.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
class Background_Image:

    PIXEL_SENSIBILITY = 0.03
    SPREADSHEET_PATH = os.path.join(os.path.dirname(__file__), "preamp_gains.csv")

    def __init__(
        self,
        ccd_operation_mode: dict,
        channel: int,
        ccd_temp: float | int = -70,
        bias_level: int = 500,
    ) -> None:
        """Initialize the class.

        Parameters
        ----------
        ccd_operation_mode : dict
            A python dictionary with the CCD operation mode.
            The allowed keywords values for the dictionary are: em_mode, em_gain,
            readout, preamp, binn, t_exp, image_size, temp.
        channel : [1, 2, 3, or 4]
            Channel ID
        ccd_temp : float | int, optional
            The CCD temperature in celsius degree.
        bias_level : int, optional
            The bias level of the image in ADU.
        """

        self.bias_level = bias_level
        self.channel = channel
        self.ccd_operation_mode = ccd_operation_mode

        self._NOISE_FACTOR = 1
        if ccd_operation_mode["em_mode"] == "EM":
            self._NOISE_FACTOR = 1.4

        noise = Noise(channel)  # ? Injeção de dependência
        self.read_noise = noise.calculate_read_noise(ccd_operation_mode)
        self.dark_noise = (
            noise.calculate_dark_current(ccd_temp) * ccd_operation_mode["t_exp"]
        )
        self._get_ccd_gain()

    def _get_ccd_gain(self) -> None:
        idx_tab = 0
        readout = self.ccd_operation_mode["readout"]
        if self.ccd_operation_mode["em_mode"] == "EM":
            idx_tab = [30, 20, 10, 1].index(readout) * 2
        else:
            idx_tab = [1, 0.1].index(readout) * 2 + 8
        idx_tab += self.ccd_operation_mode["preamp"] - 1
        ss = pd.read_csv(self.SPREADSHEET_PATH)
        self.ccd_gain = ss[f"CH{self.channel}"][idx_tab]

    def create_bias_background(self, seed: float = 1) -> ndarray:
        """Create the bias background.

        This functions creates a bias background with a noise distribution given by
        a gaussian distribution over the read noise.

        Parameters
        ----------
        seed: float, optional
            A seed for the creating of the noise image.

        Returns
        -------
        array like:
            A bias background for the respective CCD operation mode.
        """

        image_size = self.ccd_operation_mode["image_size"]
        shape = (image_size, image_size)
        noise_adu = self.read_noise / self.ccd_gain
        bias_background = make_noise_image(
            shape,
            distribution="gaussian",
            mean=self.bias_level,
            stddev=noise_adu,
            seed=seed,
        )

        return bias_background

    def create_dark_background(self, seed: float = 1) -> ndarray:
        """Create a dark background.

        This functions creates a dark background given by the ccd operation mode,
        the dc noise, and the bias level.
        This background is created woth a noise given by a gaussian
        distribution over the read noise and dc noise. Also, the
        extra noise of the EM amplification is considered.

        Parameters
        ----------
        seed: float, optional
            A seed for the creating of the noise image.

        Returns
        -------
        array like:
            A dark background for the respective CCD operation mode and the dc level.
        """

        image_size = self.ccd_operation_mode["image_size"]
        em_gain = self.ccd_operation_mode["em_gain"]
        binn = self.ccd_operation_mode["binn"]
        shape = (image_size, image_size)
        dark_level = (
            self.bias_level + self.dark_noise * em_gain * binn**2 / self.ccd_gain
        )

        noise = (
            np.sqrt(
                self.read_noise**2
                + self.dark_noise * self._NOISE_FACTOR**2 * em_gain**2 * binn**2
            )
            / self.ccd_gain
        )

        dark_background = make_noise_image(
            shape, distribution="gaussian", mean=dark_level, stddev=noise, seed=seed
        )

        return dark_background

    def create_flat_background(self, seed: float = 1) -> ndarray:
        """Create a flat background.

        This functions creates a flat background with a noise distribution given by
        the contribution of the read noise, the Poisson noise,
        and the pixel sensibility noise.
        The extra noise related with the EM amplification is also considered.

        Parameters
        ----------
        seed: float, optional
            A seed for the creating of the noise image.

        Returns
        -------
        flat_background: array like
            A flat background with counts distribution around half of the
            pixels depth.
        """
        em_gain = self.ccd_operation_mode["em_gain"]
        binn = self.ccd_operation_mode["binn"]
        image_size = self.ccd_operation_mode["image_size"]
        FLAT_LEVEL = 2**15  # ADU
        if self.ccd_operation_mode["preamp"] == 1:
            FLAT_LEVEL /= 2

        poisson_noise = FLAT_LEVEL / self.ccd_gain
        shape = (image_size, image_size)

        noise = (
            np.sqrt(
                self.read_noise**2
                + (poisson_noise * (1 + self.PIXEL_SENSIBILITY) + self.dark_noise)
                * self._NOISE_FACTOR**2
                * em_gain**2
                * binn**2
            )
            / self.ccd_gain
        )

        flat_background = make_noise_image(
            shape, distribution="gaussian", mean=FLAT_LEVEL, stddev=noise, seed=seed
        )

        return flat_background

    def create_sky_background(self, sky_flux: float, seed: float = 1) -> ndarray:
        """Create a sky background.

        This functions creates a sky background given
        by the sky flux, the dark noise, and the bias
        level. Over this background, there is a noise given by the read noise,
        dark noise, and sky noise.
        The extra noise of the EM amplification is also considered.

        Parameters
        ----------
        sky_flux : float
            Photons/s of the sky.
        seed: float
            A seed for the creating of the noise image. Default to 1.

        Returns
        -------
        array like:
            A sky background for the respective sky flux, and the dark noise.

        """
        t_exp = self.ccd_operation_mode["t_exp"]
        em_gain = self.ccd_operation_mode["em_gain"]
        binn = self.ccd_operation_mode["binn"]
        image_size = self.ccd_operation_mode["image_size"]

        sky_background = (
            self.bias_level
            + (self.dark_noise + sky_flux) * t_exp * em_gain * binn**2 / self.ccd_gain
        )

        noise = (
            np.sqrt(
                self.read_noise**2
                + (sky_flux * t_exp + self.dark_noise)
                * self._NOISE_FACTOR**2
                * em_gain**2
                * binn**2
            )
            / self.ccd_gain
        )

        shape = (image_size, image_size)
        sky_background = make_noise_image(
            shape, distribution="gaussian", mean=sky_background, stddev=noise, seed=seed
        )

        return sky_background

__init__(ccd_operation_mode, channel, ccd_temp=-70, bias_level=500)

Initialize the class.

Parameters:

Name Type Description Default
ccd_operation_mode dict

A python dictionary with the CCD operation mode. The allowed keywords values for the dictionary are: em_mode, em_gain, readout, preamp, binn, t_exp, image_size, temp.

 required
channel [1, 2, 3, or 4]

Channel ID

 required
ccd_temp float | int

The CCD temperature in celsius degree.

 -70
bias_level int

The bias level of the image in ADU.

 500
Source code in AIS/Background_Image/background_image.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def __init__(
    self,
    ccd_operation_mode: dict,
    channel: int,
    ccd_temp: float | int = -70,
    bias_level: int = 500,
) -> None:
    """Initialize the class.

    Parameters
    ----------
    ccd_operation_mode : dict
        A python dictionary with the CCD operation mode.
        The allowed keywords values for the dictionary are: em_mode, em_gain,
        readout, preamp, binn, t_exp, image_size, temp.
    channel : [1, 2, 3, or 4]
        Channel ID
    ccd_temp : float | int, optional
        The CCD temperature in celsius degree.
    bias_level : int, optional
        The bias level of the image in ADU.
    """

    self.bias_level = bias_level
    self.channel = channel
    self.ccd_operation_mode = ccd_operation_mode

    self._NOISE_FACTOR = 1
    if ccd_operation_mode["em_mode"] == "EM":
        self._NOISE_FACTOR = 1.4

    noise = Noise(channel)  # ? Injeção de dependência
    self.read_noise = noise.calculate_read_noise(ccd_operation_mode)
    self.dark_noise = (
        noise.calculate_dark_current(ccd_temp) * ccd_operation_mode["t_exp"]
    )
    self._get_ccd_gain()

create_bias_background(seed=1)

Create the bias background.

This functions creates a bias background with a noise distribution given by a gaussian distribution over the read noise.

Parameters:

Name Type Description Default
seed float

A seed for the creating of the noise image.

 1

Returns:

Type Description
array like:

A bias background for the respective CCD operation mode.
Source code in AIS/Background_Image/background_image.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def create_bias_background(self, seed: float = 1) -> ndarray:
    """Create the bias background.

    This functions creates a bias background with a noise distribution given by
    a gaussian distribution over the read noise.

    Parameters
    ----------
    seed: float, optional
        A seed for the creating of the noise image.

    Returns
    -------
    array like:
        A bias background for the respective CCD operation mode.
    """

    image_size = self.ccd_operation_mode["image_size"]
    shape = (image_size, image_size)
    noise_adu = self.read_noise / self.ccd_gain
    bias_background = make_noise_image(
        shape,
        distribution="gaussian",
        mean=self.bias_level,
        stddev=noise_adu,
        seed=seed,
    )

    return bias_background

create_dark_background(seed=1)

Create a dark background.

This functions creates a dark background given by the ccd operation mode, the dc noise, and the bias level. This background is created woth a noise given by a gaussian distribution over the read noise and dc noise. Also, the extra noise of the EM amplification is considered.

Parameters:

Name Type Description Default
seed float

A seed for the creating of the noise image.

 1

Returns:

Type Description
array like:

A dark background for the respective CCD operation mode and the dc level.
Source code in AIS/Background_Image/background_image.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def create_dark_background(self, seed: float = 1) -> ndarray:
    """Create a dark background.

    This functions creates a dark background given by the ccd operation mode,
    the dc noise, and the bias level.
    This background is created woth a noise given by a gaussian
    distribution over the read noise and dc noise. Also, the
    extra noise of the EM amplification is considered.

    Parameters
    ----------
    seed: float, optional
        A seed for the creating of the noise image.

    Returns
    -------
    array like:
        A dark background for the respective CCD operation mode and the dc level.
    """

    image_size = self.ccd_operation_mode["image_size"]
    em_gain = self.ccd_operation_mode["em_gain"]
    binn = self.ccd_operation_mode["binn"]
    shape = (image_size, image_size)
    dark_level = (
        self.bias_level + self.dark_noise * em_gain * binn**2 / self.ccd_gain
    )

    noise = (
        np.sqrt(
            self.read_noise**2
            + self.dark_noise * self._NOISE_FACTOR**2 * em_gain**2 * binn**2
        )
        / self.ccd_gain
    )

    dark_background = make_noise_image(
        shape, distribution="gaussian", mean=dark_level, stddev=noise, seed=seed
    )

    return dark_background

create_flat_background(seed=1)

Create a flat background.

This functions creates a flat background with a noise distribution given by the contribution of the read noise, the Poisson noise, and the pixel sensibility noise. The extra noise related with the EM amplification is also considered.

Parameters:

Name Type Description Default
seed float

A seed for the creating of the noise image.

 1

Returns:

Name Type Description
flat_background array like

A flat background with counts distribution around half of the pixels depth.
Source code in AIS/Background_Image/background_image.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def create_flat_background(self, seed: float = 1) -> ndarray:
    """Create a flat background.

    This functions creates a flat background with a noise distribution given by
    the contribution of the read noise, the Poisson noise,
    and the pixel sensibility noise.
    The extra noise related with the EM amplification is also considered.

    Parameters
    ----------
    seed: float, optional
        A seed for the creating of the noise image.

    Returns
    -------
    flat_background: array like
        A flat background with counts distribution around half of the
        pixels depth.
    """
    em_gain = self.ccd_operation_mode["em_gain"]
    binn = self.ccd_operation_mode["binn"]
    image_size = self.ccd_operation_mode["image_size"]
    FLAT_LEVEL = 2**15  # ADU
    if self.ccd_operation_mode["preamp"] == 1:
        FLAT_LEVEL /= 2

    poisson_noise = FLAT_LEVEL / self.ccd_gain
    shape = (image_size, image_size)

    noise = (
        np.sqrt(
            self.read_noise**2
            + (poisson_noise * (1 + self.PIXEL_SENSIBILITY) + self.dark_noise)
            * self._NOISE_FACTOR**2
            * em_gain**2
            * binn**2
        )
        / self.ccd_gain
    )

    flat_background = make_noise_image(
        shape, distribution="gaussian", mean=FLAT_LEVEL, stddev=noise, seed=seed
    )

    return flat_background

create_sky_background(sky_flux, seed=1)

Create a sky background.

This functions creates a sky background given by the sky flux, the dark noise, and the bias level. Over this background, there is a noise given by the read noise, dark noise, and sky noise. The extra noise of the EM amplification is also considered.

Parameters:

Name Type Description Default
sky_flux float

Photons/s of the sky.

 required
seed float

A seed for the creating of the noise image. Default to 1.

 1

Returns:

Type Description
array like:

A sky background for the respective sky flux, and the dark noise.
Source code in AIS/Background_Image/background_image.py 
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def create_sky_background(self, sky_flux: float, seed: float = 1) -> ndarray:
    """Create a sky background.

    This functions creates a sky background given
    by the sky flux, the dark noise, and the bias
    level. Over this background, there is a noise given by the read noise,
    dark noise, and sky noise.
    The extra noise of the EM amplification is also considered.

    Parameters
    ----------
    sky_flux : float
        Photons/s of the sky.
    seed: float
        A seed for the creating of the noise image. Default to 1.

    Returns
    -------
    array like:
        A sky background for the respective sky flux, and the dark noise.

    """
    t_exp = self.ccd_operation_mode["t_exp"]
    em_gain = self.ccd_operation_mode["em_gain"]
    binn = self.ccd_operation_mode["binn"]
    image_size = self.ccd_operation_mode["image_size"]

    sky_background = (
        self.bias_level
        + (self.dark_noise + sky_flux) * t_exp * em_gain * binn**2 / self.ccd_gain
    )

    noise = (
        np.sqrt(
            self.read_noise**2
            + (sky_flux * t_exp + self.dark_noise)
            * self._NOISE_FACTOR**2
            * em_gain**2
            * binn**2
        )
        / self.ccd_gain
    )

    shape = (image_size, image_size)
    sky_background = make_noise_image(
        shape, distribution="gaussian", mean=sky_background, stddev=noise, seed=seed
    )

    return sky_background