Skip to content

dataset

Module for dataset container and protocols for defining the spec of the required functions for all datasets.

DataSet dataclass

Class for storing a dataset.

Attributes:

Name Type Description
name str

The name of the dataset.
get_files GetFiles

The function to get the file list for this dataset.
load Load

The function to load data for this dataset.
get_info GetInfo

The function to get the info dict for this dataset.
make_beam MakeBeam

The function to make the beam for this dataset.
preproc PreProc

The function to run preprocessing for this dataset.
postproc PostProc

The function to run postprocessing for this dataset.
postfit PostFit

The function to run after fitting this dataset.
info dict

The info dict for this dataset. This field is not part of the initialization function.
datavec DataVec

The data vector for this data. This will be a jitkasi container class. This field is not part of the initialization function.
Source code in witch/dataset.py 
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
@register_pytree_node_class
@dataclass
class DataSet:
    """
    Class for storing a dataset.

    Attributes
    ----------
    name : str
        The name of the dataset.
    get_files : GetFiles
        The function to get the file list for this dataset.
    load : Load
        The function to load data for this dataset.
    get_info : GetInfo
        The function to get the info dict for this dataset.
    make_beam : MakeBeam
        The function to make the beam for this dataset.
    preproc : PreProc
        The function to run preprocessing for this dataset.
    postproc : PostProc
        The function to run postprocessing for this dataset.
    postfit : PostFit
        The function to run after fitting this dataset.
    info : dict
        The info dict for this dataset.
        This field is not part of the initialization function.
    datavec : DataVec
        The data vector for this data.
        This will be a `jitkasi` container class.
        This field is not part of the initialization function.
    """

    name: str
    get_files: GetFiles
    load: Load
    get_info: GetInfo
    make_beam: MakeBeam
    preproc: PreProc
    postproc: PostProc
    postfit: PostFit
    info: dict = field(init=False)
    datavec: DataVec = field(init=False)

    def __post_init__(self: Self):
        assert isinstance(self.get_files, GetFiles)
        assert isinstance(self.load, Load)
        assert isinstance(self.get_info, GetInfo)
        assert isinstance(self.make_beam, MakeBeam)
        assert isinstance(self.preproc, PreProc)
        assert isinstance(self.postproc, PostProc)
        assert isinstance(self.postfit, PostFit)

    def __setattr__(self, name, value):
        if name == "info":
            if "mode" not in value:
                raise ValueError("Cannot set dataset info without a 'mode' field")
            if value["mode"] not in ["tod", "map"]:
                raise ValueError("Dataset info contained invalid mode")
            if "objective" not in value:
                raise ValueError("Cannot set dataset info without an 'objective' field")
            if not isinstance(value["objective"], ObjectiveFunc):
                raise ValueError("Dataset info contained invalid objective function")
        return super().__setattr__(name, value)

    @property
    def mode(self: Self) -> str:
        """
        Get the mode for this dataset.
        Will be `tod` or `map`.

        Returns
        -------
        mode : str
            The dataset mode.
        """
        return self.info["mode"]

    @property
    def objective(self: Self) -> ObjectiveFunc:
        """
        Get the objective function for this dataset.

        Returns
        -------
        objective : ObjectiveFunc
            The objective function.
        """
        return self.info["objective"]

    @property
    def noise_class(self: Self) -> NoiseModel:
        """
        Get the noise class for this dataset.

        Returns
        -------
        noise_class : NoiseModel
            The class of the noise model that will be used for this dataset.
            This field is not part of the initialization function.
        """
        return self.info["noise_class"]

    @property
    def noise_args(self: Self) -> tuple:
        """
        Get the noise arguments for this dataset.

        Returns
        -------
        noise_args : tuple
            Positional arguments to be used by the noise model.
            This field is not part of the initialization function.
        """
        return self.info["noise_args"]

    @property
    def noise_kwargs(self: Self) -> tuple:
        """
        Get the noise keyword arguments for this dataset.

        Returns
        -------
        noise_kwargs : dict
            Keyword arguments to be used by the noise model.
            This field is not part of the initialization function.
        """
        return self.info["noise_kwargs"]

    def check_completeness(self: Self):
        """
        Check if all fields are actually populated and raise an error if not.

        Raises
        ------
        ValueError
            If the dataset is missing some fields.
            If `self.info` is missing some required info.
            If `self.mode` is not a valid mode.
            If `self.objective` is not a valid objective function.
        """
        missing = [
            fname
            for fname in self.__dataclass_fields__.keys()
            if fname not in self.__dict__
        ]
        if len(missing) > 0:
            raise ValueError(f"Datset is missing the following fields: {missing}")

        required_info = np.array(
            ["mode", "objective", "noise_class", "noise_args", "noise_kwargs"]
        )
        contained_info = list(self.info.keys())
        missing_info = required_info[~np.isin(required_info, contained_info)]
        if len(missing_info) > 0:
            raise ValueError(
                f"(Dataset info is missing the following fields: {missing_info}"
            )

        if self.info["mode"] not in ["tod", "map"]:
            raise ValueError("Dataset info contained invalid mode")
        if not isinstance(self.info["objective"], ObjectiveFunc):
            raise ValueError("Dataset info contained invalid objective function")

    # Functions for making this a pytree
    # Don't call this on your own
    def tree_flatten(self) -> tuple[tuple, tuple]:
        if "datavec" in self.__dict__:
            children = (self.datavec,)
        else:
            children = (None,)
        aux_data = (
            self.name,
            self.get_files,
            self.load,
            self.get_info,
            self.make_beam,
            self.preproc,
            self.postproc,
            self.postfit,
        )
        if "info" in self.__dict__:
            aux_data += (self.info,)
        else:
            aux_data += (None,)

        return (children, aux_data)

    @classmethod
    def tree_unflatten(cls, aux_data, children) -> Self:
        (datavec,) = children
        name = aux_data[0]
        funcs = aux_data[1:8]
        info = aux_data[8]
        dataset = cls(name, *funcs)
        if datavec is not None:
            dataset.datavec = datavec
        if info is not None:
            dataset.info = info
        return dataset

mode property

Get the mode for this dataset. Will be tod or map.

Returns:

Name Type Description
mode str

The dataset mode.

noise_args property

Get the noise arguments for this dataset.

Returns:

Name Type Description
noise_args tuple

Positional arguments to be used by the noise model. This field is not part of the initialization function.

noise_class property

Get the noise class for this dataset.

Returns:

Name Type Description
noise_class NoiseModel

The class of the noise model that will be used for this dataset. This field is not part of the initialization function.

noise_kwargs property

Get the noise keyword arguments for this dataset.

Returns:

Name Type Description
noise_kwargs dict

Keyword arguments to be used by the noise model. This field is not part of the initialization function.

objective property

Get the objective function for this dataset.

Returns:

Name Type Description
objective ObjectiveFunc

The objective function.

check_completeness()

Check if all fields are actually populated and raise an error if not.

Raises:

Type Description
ValueError

If the dataset is missing some fields. If self.info is missing some required info. If self.mode is not a valid mode. If self.objective is not a valid objective function.
Source code in witch/dataset.py 
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
def check_completeness(self: Self):
    """
    Check if all fields are actually populated and raise an error if not.

    Raises
    ------
    ValueError
        If the dataset is missing some fields.
        If `self.info` is missing some required info.
        If `self.mode` is not a valid mode.
        If `self.objective` is not a valid objective function.
    """
    missing = [
        fname
        for fname in self.__dataclass_fields__.keys()
        if fname not in self.__dict__
    ]
    if len(missing) > 0:
        raise ValueError(f"Datset is missing the following fields: {missing}")

    required_info = np.array(
        ["mode", "objective", "noise_class", "noise_args", "noise_kwargs"]
    )
    contained_info = list(self.info.keys())
    missing_info = required_info[~np.isin(required_info, contained_info)]
    if len(missing_info) > 0:
        raise ValueError(
            f"(Dataset info is missing the following fields: {missing_info}"
        )

    if self.info["mode"] not in ["tod", "map"]:
        raise ValueError("Dataset info contained invalid mode")
    if not isinstance(self.info["objective"], ObjectiveFunc):
        raise ValueError("Dataset info contained invalid objective function")

GetFiles

Bases: Protocol

Function that returns a list of files to be loaded for this dataset. Technically these do not have the be filepaths, just a list where each entry is the information needed to load the data. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
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
@runtime_checkable
class GetFiles(Protocol):
    """
    Function that returns a list of files to be loaded for this dataset.
    Technically these do not have the be filepaths, just a list where each
    entry is the information needed to load the data.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(self: Self, dset_name: str, cfg: dict) -> list:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.

        Returns
        -------
        file_list : list
            A list where each entry contains the information needed to load a
            discrete piece of data (ie: a TOD or map) for this dataset.
            The format of the entries are up to the dataset but the number of
            entries must match the number of things loaded for MPI planning
            purposes.
        """
        ...

__call__(dset_name, cfg)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required

Returns:

Name Type Description
file_list list

A list where each entry contains the information needed to load a discrete piece of data (ie: a TOD or map) for this dataset. The format of the entries are up to the dataset but the number of entries must match the number of things loaded for MPI planning purposes.
Source code in witch/dataset.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def __call__(self: Self, dset_name: str, cfg: dict) -> list:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.

    Returns
    -------
    file_list : list
        A list where each entry contains the information needed to load a
        discrete piece of data (ie: a TOD or map) for this dataset.
        The format of the entries are up to the dataset but the number of
        entries must match the number of things loaded for MPI planning
        purposes.
    """
    ...

GetInfo

Bases: Protocol

Function that gets information that will be used by other functions for this dataset. At the minimum this should contain:

  • mode: a string that is either tod or map that detemines how the dataset is treated.
  • objective: a function pointer to an objective function. See witch.objective.ObjectiveFunc for details.

See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
 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
@runtime_checkable
class GetInfo(Protocol):
    """
    Function that gets information that will be used by other functions for this dataset.
    At the minimum this should contain:

    * `mode`: a string that is either `tod` or `map` that detemines how the dataset is treated.
    * `objective`: a function pointer to an objective function. See `witch.objective.ObjectiveFunc` for details.

    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(self: Self, dset_name: str, cfg: dict, datavec: DataVec) -> dict:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.


        Returns
        -------
        info : dict
            Dictionairy containing information.
            Must at least contain `mode` and `objective`.
        """
        ...

__call__(dset_name, cfg, datavec)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
datavec DataVec

The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.

 required

Returns:

Name Type Description
info dict

Dictionairy containing information. Must at least contain mode and objective.
Source code in witch/dataset.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def __call__(self: Self, dset_name: str, cfg: dict, datavec: DataVec) -> dict:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.


    Returns
    -------
    info : dict
        Dictionairy containing information.
        Must at least contain `mode` and `objective`.
    """
    ...

Load

Bases: Protocol

Function that loads data into a jitkasi container. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
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
@runtime_checkable
class Load(Protocol):
    """
    Function that loads data into a `jitkasi` container.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self, dset_name: str, cfg: dict, fnames: list, comm: MPI.Intracomm
    ) -> DataVec:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        fnames : list
            Some subset of the output of `GetFiles`.
        comm : MPI.Intracomm
            The MPI communicator to pass to the `jitkasi` container.

        Returns
        -------
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.
        """
        ...

__call__(dset_name, cfg, fnames, comm)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
fnames list

Some subset of the output of GetFiles.

 required
comm Intracomm

The MPI communicator to pass to the jitkasi container.

 required

Returns:

Name Type Description
datavec DataVec

The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.
Source code in witch/dataset.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def __call__(
    self: Self, dset_name: str, cfg: dict, fnames: list, comm: MPI.Intracomm
) -> DataVec:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    fnames : list
        Some subset of the output of `GetFiles`.
    comm : MPI.Intracomm
        The MPI communicator to pass to the `jitkasi` container.

    Returns
    -------
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.
    """
    ...

MakeBeam

Bases: Protocol

Function that makes the beam array. If you don't need a beam just write a dummy function to return jnp.array([[1]]). See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
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
@runtime_checkable
class MakeBeam(Protocol):
    """
    Function that makes the beam array.
    If you don't need a beam just write a dummy function to return `jnp.array([[1]])`.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(self: Self, dset_name: str, cfg: dict, info: dict) -> Array:
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        info : dict
            Dictionairy containing dataset information.

        Returns
        -------
        beam : Array
            The beam to be convolved with the model.
            Should be a 2D array.
        """
        ...

__call__(dset_name, cfg, info)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
info dict

Dictionairy containing dataset information.

 required

Returns:

Name Type Description
beam Array

The beam to be convolved with the model. Should be a 2D array.
Source code in witch/dataset.py 
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
def __call__(self: Self, dset_name: str, cfg: dict, info: dict) -> Array:
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    info : dict
        Dictionairy containing dataset information.

    Returns
    -------
    beam : Array
        The beam to be convolved with the model.
        Should be a 2D array.
    """
    ...

PostFit

Bases: Protocol

Function that runs after all fitting stages are over. This is where you may want make some visualization or initial analysis of your data (ie. plot residuals, check statistical significance, etc.) You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
@runtime_checkable
class PostFit(Protocol):
    """
    Function that runs after all fitting stages are over.
    This is where you may want make some visualization or initial analysis of your data
    (ie. plot residuals, check statistical significance, etc.)
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset_name: str,
        cfg: dict,
        datavec: DataVec,
        model: Model,
        info: dict,
    ):
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.
        model : Model
            The cluster model.
            This will contain the final best fit parameters.
        info : dict
            Dictionairy containing dataset information.
        """
        ...

__call__(dset_name, cfg, datavec, model, info)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
datavec DataVec

The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.

 required
model Model

The cluster model. This will contain the final best fit parameters.

 required
info dict

Dictionairy containing dataset information.

 required
Source code in witch/dataset.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
def __call__(
    self: Self,
    dset_name: str,
    cfg: dict,
    datavec: DataVec,
    model: Model,
    info: dict,
):
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.
    model : Model
        The cluster model.
        This will contain the final best fit parameters.
    info : dict
        Dictionairy containing dataset information.
    """
    ...

PostProc

Bases: Protocol

Function that runs after the data vector is processed. (see witch.fitter.process_tods and witch.fitter.process_maps). This is where you may want make some visualization or initial analysis of your data (ie. make a map from your TODs, improve the noise model estimation, etc.) You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
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
@runtime_checkable
class PostProc(Protocol):
    """
    Function that runs after the data vector is processed.
    (see `witch.fitter.process_tods` and `witch.fitter.process_maps`).
    This is where you may want make some visualization or initial analysis of your data
    (ie. make a map from your TODs, improve the noise model estimation, etc.)
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset_name: str,
        cfg: dict,
        datavec: DataVec,
        model: Model,
        info: dict,
    ):
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.
        model : Model
            The cluster model.
            At this point this will just be the initial state of the model.
        info : dict
            Dictionairy containing dataset information.
        """
        ...

__call__(dset_name, cfg, datavec, model, info)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
datavec DataVec

The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.

 required
model Model

The cluster model. At this point this will just be the initial state of the model.

 required
info dict

Dictionairy containing dataset information.

 required
Source code in witch/dataset.py 
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
def __call__(
    self: Self,
    dset_name: str,
    cfg: dict,
    datavec: DataVec,
    model: Model,
    info: dict,
):
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.
    model : Model
        The cluster model.
        At this point this will just be the initial state of the model.
    info : dict
        Dictionairy containing dataset information.
    """
    ...

PreProc

Bases: Protocol

Function that runs before the data vector is processed. (see witch.fitter.process_tods and witch.fitter.process_maps). This is where you may want to compute something about the data's noise properties or some other statistic that may be useful to your analysis. You can also do nothing if you wish. See docstring of __call__ for details on the parameters and returns.

Source code in witch/dataset.py 
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
@runtime_checkable
class PreProc(Protocol):
    """
    Function that runs before the data vector is processed.
    (see `witch.fitter.process_tods` and `witch.fitter.process_maps`).
    This is where you may want to compute something about the data's noise properties
    or some other statistic that may be useful to your analysis.
    You can also do nothing if you wish.
    See docstring of `__call__` for details on the parameters and returns.
    """

    def __call__(
        self: Self,
        dset_name: str,
        cfg: dict,
        datavec: DataVec,
        model: Model,
        info: dict,
    ):
        """
        Parameters
        ----------
        dset_name : str
            The name of the dataset to get file list for.
        cfg : dict
            The loaded `witcher` config.
        datavec : DataVec
            The `jitkasi` container for the data.
            This is going to be `TODVec` for TODs
            and `SolutionSet` for maps.
        model : Model
            The cluster model.
            At this point this will just be the initial state of the model.
        info : dict
            Dictionairy containing dataset information.
        """
        ...

__call__(dset_name, cfg, datavec, model, info)

Parameters:

Name Type Description Default
dset_name str

The name of the dataset to get file list for.

 required
cfg dict

The loaded witcher config.

 required
datavec DataVec

The jitkasi container for the data. This is going to be TODVec for TODs and SolutionSet for maps.

 required
model Model

The cluster model. At this point this will just be the initial state of the model.

 required
info dict

Dictionairy containing dataset information.

 required
Source code in witch/dataset.py 
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
def __call__(
    self: Self,
    dset_name: str,
    cfg: dict,
    datavec: DataVec,
    model: Model,
    info: dict,
):
    """
    Parameters
    ----------
    dset_name : str
        The name of the dataset to get file list for.
    cfg : dict
        The loaded `witcher` config.
    datavec : DataVec
        The `jitkasi` container for the data.
        This is going to be `TODVec` for TODs
        and `SolutionSet` for maps.
    model : Model
        The cluster model.
        At this point this will just be the initial state of the model.
    info : dict
        Dictionairy containing dataset information.
    """
    ...