def __init__(self, pdgid, pdg_name, mass=attr_dict['mass'].default, mass_upper=attr_dict['mass_upper'].default, mass_lower=attr_dict['mass_lower'].default, width=attr_dict['width'].default, width_upper=attr_dict['width_upper'].default, width_lower=attr_dict['width_lower'].default, three_charge=attr_dict['_three_charge'].default, I=attr_dict['I'].default, G=attr_dict['G'].default, P=attr_dict['P'].default, C=attr_dict['C'].default, anti_flag=attr_dict['anti_flag'].default, rank=attr_dict['rank'].default, status=attr_dict['status'].default, quarks=attr_dict['quarks'].default, latex_name=attr_dict['latex_name'].default):
    self.pdgid = __attr_converter_pdgid(pdgid)
    self.pdg_name = pdg_name
    self.mass = __attr_converter_mass(mass)
    self.mass_upper = __attr_converter_mass_upper(mass_upper)
    self.mass_lower = __attr_converter_mass_lower(mass_lower)
    self.width = __attr_converter_width(width)
    self.width_upper = __attr_converter_width_upper(width_upper)
    self.width_lower = __attr_converter_width_lower(width_lower)
    self._three_charge = __attr_converter__three_charge(three_charge)
    self.I = __attr_converter_I(I)
    self.G = __attr_converter_G(G)
    self.P = __attr_converter_P(P)
    self.C = __attr_converter_C(C)
    self.anti_flag = __attr_converter_anti_flag(anti_flag)
    self.rank = rank
    self.status = __attr_converter_status(status)
    self.quarks = __attr_converter_quarks(quarks)
    self.latex_name = latex_name

def describe(self) -> str:
    "Make a nice high-density string for a particle's properties."
    if self.pdgid == 0:
        return "Name: Unknown"
    G = Parity_undo[self.G]
    C = Parity_undo[self.C]
    Q = self._str_charge()
    P = Parity_undo[self.P]
    mass = self._str_mass()
    width_or_lifetime = self._width_or_lifetime()
    latex_name = self._repr_latex_()
    val = f"""Name: {self!s:<14} ID: {self.pdgid:<12} Latex: {latex_name}
  = {mass}
th_or_lifetime}
harge)        = {Q:<6}  J (total angular) = {self.J!s:<7}  P (space parity) = {P}
harge parity) = {C:<6}  I (isospin)       = {self.I!s:<7}  G (G-parity)     = {G}
    if self.spin_type != SpinType.Unknown:
        val += f"    SpinType: {self.spin_type!s}\n"
    if self.quarks:
        val += f"    Quarks: {self.quarks}\n"
    val += f"    Antiparticle name: {self.invert().name} (antiparticle status: {self.anti_flag.name})"
    return val

def invert(self: Self) -> Self:
    "Get the antiparticle."
    if self.anti_flag == Inv.Barred or (
        self.anti_flag == Inv.ChargeInv and self.three_charge != Charge.o
    ):
        return self.from_pdgid(-self.pdgid)
    return copy(self)

@classmethod
def all(cls: type[Self]) -> list[Self]:
    """
    Access, hence get hold of, the internal particle data CSV table,
    loading it from the default location if no table has yet been loaded.
    All `Particle` (instances) are returned as a list.
    """
    if not cls.table_loaded():
        cls.load_table()
    return cls._table if cls._table is not None else []  # type: ignore[return-value]

@classmethod
def empty(cls: type[Self]) -> Self:
    "Make a new empty particle."
    return cls(0, "Unknown", anti_flag=Inv.Same)

@classmethod
def findall(
    cls: type[Self],
    filter_fn: Callable[[Particle], bool] | None = None,
    *,
    particle: bool | None = None,
    **search_terms: Any,
) -> list[Self]:
    """
    Search for a particle, returning a list of candidates.
    The first and only positional argument is given to each particle
    candidate, and returns True/False. Example:
        >>> Particle.findall(lambda p: 'p' in p.name)    # doctest: +SKIP
        # Returns list of all particles with p somewhere in name
    You can pass particle=True/False to force a particle or antiparticle.
    If this is not callable, it will do a "fuzzy" search on the name. So this is identical:
        >>> Particle.findall('p')    # doctest: +SKIP
        # Returns list of all particles with p somewhere in name (same as example above)
    You can also pass keyword arguments, which are either called with the
    matching property if they are callable, or are compared if they are not.
    This would do an exact search on the name, instead of a fuzzy search:
       >>> # Returns proton and antiproton only
       >>> Particle.findall(pdg_name='p')    # doctest: +NORMALIZE_WHITESPACE
       [<Particle: name="p", pdgid=2212, mass=938.2720882 ± 0.0000003 MeV>,
        <Particle: name="p~", pdgid=-2212, mass=938.2720882 ± 0.0000003 MeV>,
        <Particle: name="p", pdgid=1000010010, mass=938.2720882 ± 0.0000003 MeV>,
        <Particle: name="p~", pdgid=-1000010010, mass=938.2720882 ± 0.0000003 MeV>]
       >>> # Returns proton only
       >>> Particle.findall(pdg_name='p', particle=True)    # doctest: +NORMALIZE_WHITESPACE
       [<Particle: name="p", pdgid=2212, mass=938.2720882 ± 0.0000003 MeV>,
       <Particle: name="p", pdgid=1000010010, mass=938.2720882 ± 0.0000003 MeV>]
    Versatile searches require a (lambda) function as argument:
    >>> # Get all neutral beauty hadrons
    >>> Particle.findall(lambda p: p.pdgid.has_bottom and p.charge==0)    # doctest: +SKIP
    >>>
    >>> # Trivially find all pseudoscalar charm mesons
    >>> Particle.findall(lambda p: p.pdgid.is_meson and p.pdgid.has_charm and p.spin_type==SpinType.PseudoScalar)  # doctest: +SKIP
    See also ``finditer``, which provides an iterator instead of a list.
    """
    return list(
        cls.finditer(filter_fn=filter_fn, particle=particle, **search_terms)
    )

@classmethod
def finditer(
    cls: type[Self],
    filter_fn: Callable[[Particle], bool] | str | None = None,
    *,
    particle: bool | None = None,
    **search_terms: Any,
) -> Iterator[Self]:
    """
    Search for a particle, returning an iterator of candidates.
    The first and only positional argument is given to each particle
    candidate, and returns True/False. Example:
        >>> Particle.finditer(lambda p: 'p' in p.name)    # doctest: +SKIP
        # Returns iterator of all particles with p somewhere in name
    You can pass particle=True/False to force a particle or antiparticle.
    If this is not callable, it will do a "fuzzy" search on the name. So this is identical:
        >>> Particle.finditer('p')    # doctest: +SKIP
        # Returns literator of all particles with p somewhere in name (same as example above)
    You can also pass keyword arguments, which are either called with the
    matching property if they are callable, or are compared if they are not.
    This would do an exact search on the name, instead of a fuzzy search:
       >>> # Returns proton and antiproton only
       >>> Particle.finditer(pdg_name='p')    # doctest: +SKIP
       # Returns iterator
       >>> # Returns proton only
       >>> Particle.finditer(pdg_name='p', particle=True)    # doctest: +SKIP
       # Returns iterator
    Versatile searches require a (lambda) function as argument:
    >>> # Get all neutral beauty hadrons
    >>> Particle.finditer(lambda p: p.pdgid.has_bottom and p.charge==0)    # doctest: +SKIP
    >>>
    >>> # Trivially find all pseudoscalar charm mesons
    >>> Particle.finditer(lambda p: p.pdgid.is_meson and p.pdgid.has_charm and p.spin_type==SpinType.PseudoScalar)  # doctest: +SKIP
    See also ``findall``, which returns the same thing, but as a list.
    """
    # Filter out values
    for item in cls.all():
        # At this point, continue if a match fails
        # particle=True is particle, False is antiparticle, and None is both
        if particle is not None:
            if particle and int(item.pdgid) < 0:
                continue
            if (not particle) and int(item.pdgid) > 0:
                continue
        # If a filter function is passed, evaluate and skip if False
        if filter_fn is not None:
            if callable(filter_fn):
                # Just skip exceptions, which are there for good reasons
                # Example: calls to Particle.ctau for particles given
                #          default negative, and hence invalid, widths
                try:
                    if not filter_fn(item):
                        continue
                except TypeError:  # skip checks such as 'lambda p: p.width > 0',
                    continue  # which fail when width=None
            elif filter_fn not in item.name:
                continue
        # At this point, if you break, you will not add a match
        for term, value in search_terms.items():
            # If pvalue cannot be accessed, skip this particle
            # (invalid lifetime, for example)
            try:
                pvalue = getattr(item, term)
            except ValueError:
                break
            # Callables are supported
            if callable(value):
                try:
                    if not value(pvalue):
                        break
                except TypeError:  # catch issues with None values
                    break
            # And, finally, just compare if nothing else matched
            elif pvalue != value:
                break
        # If the loop was not broken
        else:
            yield item

@classmethod
def flavio_all(cls):
    return {particle for particle in cls.all() if particle.flavio_name}

@classmethod
def from_evtgen_name(cls: type[Self], name: str) -> Self:
    """
    Get a particle from an EvtGen particle name, as in .dec decay files.
    Raises
    ------
    ParticleNotFound
        If `from_pdgid`, internally called, returns no match.
    MatchingIDNotFound
        If the matching EvtGen name - PDG ID done internally is unsuccessful.
    """
    return cls.from_pdgid(EvtGenName2PDGIDBiMap[name])

@classmethod
def from_flavio_name(cls, flavio_name):
    return cls.from_pdgid(cls.PDG_PARTICLES[flavio_name])

@classmethod
def from_name(cls: type[Self], name: str) -> Self:
    """
    Get a particle from its name.
    Raises
    ------
    ParticleNotFound
        If no particle matches the input name uniquely and exactly.
    """
    try:
        (particle,) = cls.finditer(
            name=name
        )  # throws an error if < 1 or > 1 particle is found
        return particle
    except ValueError:
        raise ParticleNotFound(f"Could not find name {name!r}") from None

@classmethod
def from_nucleus_info(
    cls: type[Self],
    z: int,
    a: int,
    anti: bool = False,
    i: int = 0,
    l_strange: int = 0,
) -> Self:
    """
    Get a nucleus particle from the proton Z and atomic mass A numbers.
    As described in the PDG numbering scheme:
    "To avoid ambiguities, nucleus codes should not be applied to a single hadron, such as the p, n
    or the Λ, where quark-contents-based codes already exist."
    Number of neutrons is equal to a-z.
    The PDG ID format is ±10LZZZAAAI, see the `is_nucleus()` function in submodule
    `particle.pdgid.functions.py`.
    Parameters
    ----------
    z: int
        Atomic number Z (number of protons).
        Maximum three decimal digits.
    a: int
        Atomic mass number A (total number of baryons).
        Maximum three decimal digits.
    anti: bool, optional, defaults to False (not antimatter).
        Whether the nucleus should be antimatter.
    i: int, optional, default is 0
        Isomer level I. I=0 corresponds to the ground-state.
        I>0 are excitations.
        Maximum is one decimal digit.
    l_strange: int, optional, default is 0
        Total number of strange quarks.
        Maximum is one decimal digit.
    Raises
    ------
    ParticleNotFound
        If `from_pdgid`, internally called, returns no match.
    InvalidParticle
        If the input combination is invalid.
    """
    if l_strange < 0 or l_strange > 9:
        raise InvalidParticle(
            f"Number of strange quarks l={l_strange} is invalid. Must be 0 <= l <= 9."
        )
    if z < 0 or z > 999:
        raise InvalidParticle(
            f"Atomic number Z={z} is invalid. Must be 0 <= A <= 999."
        )
    if a < 0 or a > 999:
        raise InvalidParticle(
            f"Atomic mass number A={a} is invalid. Must be 0 <= A <= 999."
        )
    if i < 0 or i > 9:
        raise InvalidParticle(
            f"Isomer level I={i} is invalid. Must be 0 <= I <= 9."
        )
    if z > a:
        raise InvalidParticle(
            f"Nucleus A={a}, Z={z} is invalid. Z must be smaller or equal to Z."
        )
    pdgid = int(1e9 + l_strange * 1e5 + z * 1e4 + a * 10 + i)
    if anti:
        return cls.from_pdgid(-pdgid)
    return cls.from_pdgid(pdgid)

@classmethod
def from_pdgid(cls: type[Self], value: SupportsInt) -> Self:
    """
    Get a particle from a PDGID. Uses by default the package
    extended PDG data table.
    Raises
    ------
    InvalidParticle
        If the input PDG ID is an invalid identification code.
    ParticleNotFound
        If no matching PDG ID is found in the loaded data table(s).
    """
    if not is_valid(value):
        raise InvalidParticle(f"Input PDGID {value} is invalid!")
    if not cls.table_loaded():
        cls.load_table()
    assert cls._hash_table is not None
    try:
        return cls._hash_table[int(value)]  # type: ignore[return-value]
    except KeyError:
        raise ParticleNotFound(f"Could not find PDGID {value}") from None

@classmethod
@deprecated(
    version="0.22",
    reason="This method is deprecated and will be removed from version 0.23.0. Use finditer or findall instead.",
)
def from_string(cls: type[Self], name: str) -> Self:
    "Get a particle from a PDG style name - returns the best match."
    matches = cls.from_string_list(name)
    if matches:
        return matches[0]
    raise ParticleNotFound(f"{name} not found in particle table")

@classmethod
@deprecated(
    version="0.22",
    reason="This method is deprecated and will be removed from version 0.23.0. Use finditer or findall instead.",
)
def from_string_list(cls: type[Self], name: str) -> list[Self]:
    "Get a list of particles from a PDG style name."
    # Forcible override
    particle = None
    short_name = name
    if "~" in name:
        short_name = name.replace("~", "")
        particle = False
    # Try the simplest searches first
    list_can = cls.findall(name=name, particle=particle)
    if list_can:
        return list_can
    list_can = cls.findall(pdg_name=short_name, particle=particle)
    if list_can:
        return list_can
    mat_str = getname.match(short_name)
    if mat_str is None:
        return []
    mat = mat_str.groupdict()
    if particle is False:
        mat["bar"] = "bar"
    try:
        return cls._from_group_dict_list(mat)
    except ParticleNotFound:
        return []

@classmethod
def load_table(
    cls,
    filename: StringOrIO | None = None,
    append: bool = False,
    _name: str | None = None,
) -> None:
    """
    Load a particle data CSV table. Optionally append to the existing data already loaded if append=True.
    As a special case, if this is called with append=True and the table is not loaded, the default will
    be loaded first before appending (set append=False if you don't want this behavior).
    A parameter is also included that should be considered private for now. It is _name, which
    will override the filename for the stored filename in _table_names.
    """
    if append and not cls.table_loaded():
        cls.load_table(append=False)  # default load
    elif not append:
        cls._table = []
        cls._hash_table = {}
        cls._table_names = []
    # Tell MyPy that this is true
    assert cls._table is not None
    assert cls._hash_table is not None
    assert cls._table_names is not None
    if filename is None:
        with data.basepath.joinpath("particle2022.csv").open() as fa:
            cls.load_table(fa, append=append, _name="particle2022.csv")
        with data.basepath.joinpath("nuclei2022.csv").open() as fb:
            cls.load_table(fb, append=True, _name="nuclei2022.csv")
        return
    if isinstance(filename, HasRead):
        tmp_name = _name or filename.name
        cls._table_names.append(tmp_name or f"{filename!r} {len(cls._table_names)}")
        open_file = filename
    elif isinstance(filename, HasOpen):
        cls._table_names.append(str(filename))
        open_file = filename.open()
    else:
        cls._table_names.append(str(filename))
        assert not isinstance(filename, Traversable)
        open_file = open(filename, encoding="utf_8")  # noqa: SIM115
    with open_file as f:
        r = csv.DictReader(line for line in f if not line.startswith("#"))
        for v in r:
            with contextlib.suppress(ValueError):
                value = int(v["ID"])
                p = cls(
                    pdgid=value,
                    mass=float(v["Mass"]),
                    mass_upper=float(v["MassUpper"]),
                    mass_lower=float(v["MassLower"]),
                    width=float(v["Width"]),
                    width_upper=float(v["WidthUpper"]),
                    width_lower=float(v["WidthLower"]),
                    I=v["I"],
                    G=int(v["G"]),
                    P=int(v["P"]),
                    C=int(v["C"]),
                    anti_flag=int(v["Anti"]),
                    three_charge=int(v["Charge"]),
                    rank=int(v["Rank"]),
                    status=int(v["Status"]),
                    pdg_name=v["Name"],
                    quarks=v["Quarks"],
                    latex_name=v["Latex"],
                )
                # Replace the previous value if it exists
                cls._hash_table[value] = p
    cls._table = sorted(cls._hash_table.values())

@classmethod
def table_loaded(cls) -> bool:
    """
    Check to see if the table is loaded.
    """
    return cls._table is not None

@classmethod
def table_names(cls) -> tuple[str, ...]:
    """
    Return the list of names loaded.
    Note
    ----
    Calling this class method will load the default table,
    if no table has so far been loaded.
    Check with table_loaded() first if you don't want this loading
    to be triggered by the call.
    """
    if cls._table_names is None:
        cls.load_table()
    if cls._table_names is not None:
        return tuple(cls._table_names)  # make a copy to avoid user manipulation
    return ()

@classmethod
def to_dict(
    cls, *args: Any, **kwargs: Any
) -> dict[str, tuple[bool | int | str | float, ...]]:
    """
    Render a search (via `findall`) on the internal particle data CSV table
    as a `dict`, loading the table from the default location if no table has yet been loaded.
    See `to_list` for details on the full function signature.
    The returned attributes are those of the class. By default all attributes
    are used as fields. Their complete list is:
        pdgid
        pdg_name
        mass
        mass_upper
        mass_lower
        width
        width_upper
        width_lower
        three_charge
        I
        G
        P
        C
        anti_flag
        rank
        status
        quarks
        latex_name
    It is possible to add as returned fields any `Particle` class property,
    e.g. 'name', `J` or `ctau`, see examples below.
    Parameters
    ----------
    exclusive_fields: list, optional, default is []
        Exclusive list of fields to print out,
        which can be any `Particle` class property.
    exclude_fields: list, optional, default is []
        List of table fields to exclude in the printout.
        Relevant only when exclusive_fields is not given.
    n_rows: int, optional, defaults to all rows
        Number of table rows to print out.
    filter_fn: function, optional, default is None
        Apply a filter to each particle.
        See `findall(...)`` for typical use cases.
    particle: bool, optional, default is None
        Pass particle=True/False to only return particles or antiparticles.
        Option passed on internally to `findall(...)``.
    search_terms: keyword arguments, optional
        See `findall(...)`` for typical use cases.
    Returns
    -------
    The particle table query as a `dict`.
    Note
    ----
    The `tabulate` package is suggested as a means to print-out
    the contents of the query as a nicely formatted table.
    Examples
    --------
    Reproduce the whole particle table kept internally:
    >>> query_as_dict = Particle.to_dict()
    Reduce the information on the particle table to the only fields
    ['pdgid', 'pdg_name'] and render the first 5 particles:
    >>> query_as_dict = Particle.to_dict(exclusive_fields=['pdgid', 'pdg_name'], n_rows=5)
    >>> from tabulate import tabulate    # doctest: +SKIP
    >>> print(tabulate(query_as_dict, headers='keys'))    # doctest: +SKIP
      pdgid  pdg_name
    -------  ----------
          1  d
         -1  d
          2  u
         -2  u
          3  s
    Request the properties of a specific list of particles:
    >>> query_as_dict = Particle.to_dict(filter_fn=lambda p: p.pdgid.is_lepton and p.charge!=0, exclusive_fields=['pdgid', 'name', 'mass', 'charge'], particle=True)
    >>> print(tabulate(query_as_dict, headers='keys', tablefmt="rst", floatfmt=".12g", numalign="decimal"))    # doctest: +SKIP
    =======  ======  ===============  ========
      pdgid  name               mass    charge
    =======  ======  ===============  ========
         11  e-         0.5109989461        -1
         13  mu-      105.6583745           -1
         15  tau-    1776.86                -1
         17  tau'-                          -1
    =======  ======  ===============  ========
    >>> query_as_dict = Particle.to_dict(filter_fn=lambda p: p.pdgid.is_lepton, pdg_name='tau', exclusive_fields=['pdgid', 'name', 'mass', 'charge'])
    >>> print(tabulate(query_as_dict, headers='keys'))    # doctest: +SKIP
      pdgid  name       mass    charge
    -------  ------  -------  --------
         15  tau-    1776.86        -1
        -15  tau+    1776.86         1
    Save it to a file:
    >>> with open('particles.txt', "w") as outfile:    # doctest: +SKIP
    ...    print(tabulate(query_as_dict, headers='keys', tablefmt="rst", floatfmt=".12g", numalign="decimal"), file=outfile)    # doctest: +SKIP
    """
    query_as_list = cls.to_list(*args, **kwargs)
    headers = query_as_list[0]
    rows = zip(*query_as_list[1:])
    return {str(h): r for h, r in zip(headers, rows)}

@classmethod
def to_list(
    cls,
    exclusive_fields: Iterable[str] = (),
    exclude_fields: Iterable[str] = (),
    n_rows: int = -1,
    filter_fn: Callable[[Particle], bool] | None = None,
    particle: bool | None = None,
    **search_terms: Any,
) -> Sequence[Sequence[bool | int | float | str]]:
    """
    Render a search (via `findall`) on the internal particle data CSV table
    as a `list`, loading the table from the default location if no table has yet been loaded.
    The returned attributes are those of the class. By default all attributes
    are used as fields. Their complete list is:
        pdgid
        pdg_name
        mass
        mass_upper
        mass_lower
        width
        width_upper
        width_lower
        three_charge
        I
        G
        P
        C
        anti_flag
        rank
        status
        quarks
        latex_name
    It is possible to add as returned fields any `Particle` class property,
    e.g. 'name', `J` or `ctau`, see examples below.
    Parameters
    ----------
    exclusive_fields: list, optional, default is []
        Exclusive list of fields to print out,
        which can be any `Particle` class property.
    exclude_fields: list, optional, default is []
        List of table fields to exclude in the printout.
        Relevant only when exclusive_fields is not given.
    n_rows: int, optional, defaults to all rows
        Number of table rows to print out.
    filter_fn: function, optional, default is None
        Apply a filter to each particle.
        See `findall(...)`` for typical use cases.
    particle: bool, optional, default is None
        Pass particle=True/False to only return particles or antiparticles.
        Option passed on internally to `findall(...)``.
    search_terms: keyword arguments, optional
        See `findall(...)`` for typical use cases.
    Returns
    -------
    The particle table query as a `list`.
    Note
    ----
    The `tabulate` package is suggested as a means to print-out
    the contents of the query as a nicely formatted table.
    Examples
    --------
    Reproduce the whole particle table kept internally:
    >>> query_as_list = Particle.to_list()
    Reduce the information on the particle table to the only fields
    ['pdgid', 'pdg_name'] and render the first 5 particles:
    >>> query_as_list = Particle.to_list(exclusive_fields=['pdgid', 'pdg_name'], n_rows=5)
    >>> from tabulate import tabulate
    >>> print(tabulate(query_as_list, headers='firstrow'))
      pdgid  pdg_name
    -------  ----------
          1  d
         -1  d
          2  u
         -2  u
          3  s
    Request the properties of a specific list of particles:
    >>> query_as_list = Particle.to_list(filter_fn=lambda p: p.pdgid.is_lepton and p.charge!=0, exclusive_fields=['pdgid', 'name', 'mass', 'charge'], particle=False)
    >>> print(tabulate(query_as_list, headers='firstrow', tablefmt="rst", floatfmt=".12g", numalign="decimal"))
    =======  ======  =============  ========
      pdgid  name             mass    charge
    =======  ======  =============  ========
        -11  e+         0.51099895         1
        -13  mu+      105.6583755          1
        -15  tau+    1776.86               1
        -17  tau'+                         1
    =======  ======  =============  ========
    >>> query_as_list = Particle.to_list(filter_fn=lambda p: p.pdgid.is_lepton, pdg_name='tau', exclusive_fields=['pdgid', 'name', 'mass', 'charge'])
    >>> print(tabulate(query_as_list, headers='firstrow'))
      pdgid  name       mass    charge
    -------  ------  -------  --------
         15  tau-    1776.86        -1
        -15  tau+    1776.86         1
    Save it to a file:
    >>> with open('particles.txt', "w") as outfile:    # doctest: +SKIP
    ...    print(tabulate(query_as_list, headers='firstrow', tablefmt="rst", floatfmt=".12g", numalign="decimal"), file=outfile)    # doctest: +SKIP
    """
    if not cls.table_loaded():
        cls.load_table()
    # Get all table headers from the class attributes
    tbl_names = [a.name for a in attr.fields(Particle)]
    # ... and replace '_three_charge' with the better, public property
    tbl_names[tbl_names.index("_three_charge")] = "three_charge"
    list_exclusive_fields = list(exclusive_fields)
    if list_exclusive_fields:
        tbl_names = list_exclusive_fields
    else:
        for fld in exclude_fields:
            with contextlib.suppress(ValueError):
                tbl_names.remove(fld)
    # Start with the full table
    tbl_all = sorted(cls.all())
    # Apply a filter, if specified
    if filter_fn is not None:
        tbl_all = cls.findall(filter_fn, particle=particle, **search_terms)
    # In any case, only keep a given number of rows?
    if n_rows >= 0:
        tbl_all = tbl_all[:n_rows]
    # Build all table rows
    tbl = [tbl_names]
    for p in tbl_all:
        tbl.append([getattr(p, attr) for attr in tbl_names])
    return tbl