def METHOD_NAME(self,
                   parameters: Dict[str, Real],
                   channel_mapping: Dict[ChannelID, Optional[ChannelID]]) -> Optional[Union[TableWaveform,
                                                                                            MultiChannelWaveform]]:
    self.validate_parameter_constraints(parameters=parameters, volatile=set())
    if all(channel_mapping[channel] is None
           for channel in self.defined_channels):
        return None
    if self.duration.evaluate_in_scope(parameters) == 0:
        return None
    mapped_channels = tuple(channel_mapping[c] for c in self._channels)
    waveform_entries = list([] for _ in range(len(self._channels)))
    for entry in self._entries:
        instantiated_entries = entry.instantiate(parameters, len(self._channels))
        for ch_entries, wf_entry in zip(waveform_entries, instantiated_entries):
            ch_entries.append(wf_entry)
    if waveform_entries[0][0].t > 0:
        for ch_entries in waveform_entries:
            ch_entries[:0] = [PointWaveformEntry(0, ch_entries[0].v, ch_entries[0].interp)]
    # filter mappings to None
    channel_entries = [(ch, ch_entries)
                       for (ch, ch_entries) in zip(mapped_channels, waveform_entries)
                       if ch is not None]
    mapped_channels, waveform_entries = zip(*channel_entries)
    waveforms = [PointWaveform.from_table(mapped_channel, ch_entries)
                 for mapped_channel, ch_entries in zip(mapped_channels, waveform_entries)]
    return MultiChannelWaveform.from_parallel(waveforms)