def from_url(cls, input_url, **kwargs):
"""
Find compatible EventSource for input_url via the `is_compatible`
method of the EventSource
Parameters
----------
input_url : str
Filename or URL pointing to an event file
kwargs
Named arguments for the EventSource
Returns
-------
instance
Instance of a compatible EventSource subclass
"""
detect_and_import_io_plugins()
available_classes = non_abstract_children(cls)
for subcls in available_classes:
if subcls.is_compatible(input_url):
return subcls(input_url=input_url, **kwargs)
raise ValueError(
'Cannot find compatible EventSource for \n'
'\turl:{}\n'
'in available EventSources:\n'
'\t{}'.format(input_url, [c.__name__ for c in available_classes])
)
def test_non_abstract_children():
"""check that we can find all constructable children"""
from ctapipe.core import non_abstract_children
class AbstractBase(ABC):
@abstractmethod
def method(self):
pass
class Child1(AbstractBase):
def method(self):
print("method of Child1")
class Child2(AbstractBase):
def method(self):
print("method of Child2")
class GrandChild(Child2):
def method(self):
print("method of GrandChild")
class AbstractChild(AbstractBase):
pass
kids = non_abstract_children(AbstractBase)
assert Child1 in kids
assert Child2 in kids
assert GrandChild in kids
assert AbstractChild not in kids
def from_url(cls, input_url, **kwargs):
"""
Find compatible EventSource for input_url via the `is_compatible`
method of the EventSource
Parameters
----------
input_url : str
Filename or URL pointing to an event file
kwargs
Named arguments for the EventSource
Returns
-------
instance
Instance of a compatible EventSource subclass
"""
if input_url == "" or input_url is None:
raise ToolConfigurationError(
"EventSource: No input_url was specified")
detect_and_import_io_plugins()
available_classes = non_abstract_children(cls)
for subcls in available_classes:
if subcls.is_compatible(input_url):
return subcls(input_url=input_url, **kwargs)
raise ValueError("Cannot find compatible EventSource for \n"
"\turl:{}\n"
"in available EventSources:\n"
"\t{}".format(input_url,
[c.__name__
for c in available_classes]))
def from_url(cls, input_url, **kwargs):
"""
Find compatible EventSource for input_url via the `is_compatible`
method of the EventSource
Parameters
----------
input_url : str
Filename or URL pointing to an event file
kwargs
Named arguments for the EventSource
Returns
-------
instance
Instance of a compatible EventSource subclass
"""
available_classes = non_abstract_children(cls)
for subcls in available_classes:
if subcls.is_compatible(input_url):
return subcls(input_url=input_url, **kwargs)
raise ValueError('Cannot find compatible EventSource for \n'
'\turl:{}\n'
'in available EventSources:\n'
'\t{}'.format(input_url,
[c.__name__
for c in available_classes]))
def enum_trait(base_class, default, help_str=None):
'''create a configurable CaselessStrEnum traitlet from baseclass
the enumeration should contain all names of non_abstract_children()
of said baseclass and the default choice should be given by
`base_class._default` name.
default must be specified and must be the name of one child-class
'''
if help_str is None:
help_str = '{} to use.'.format(base_class.__name__)
choices = [
cls.__name__
for cls in non_abstract_children(base_class)
]
if default not in choices:
raise ValueError(
'{default} is not in choices: {choices}'.format(
default=default,
choices=choices,
)
)
return CaselessStrEnum(
choices,
default,
allow_none=True,
help=help_str
).tag(config=True)
def test_non_abstract_children():
from ctapipe.core import non_abstract_children
class AbstractBase(ABC):
@abstractmethod
def method(self):
pass
class Child1(AbstractBase):
def method(self):
print('method of Child1')
class Child2(AbstractBase):
def method(self):
print('method of Child2')
class GrandChild(Child2):
def method(self):
print('method of GrandChild')
class AbstractChild(AbstractBase):
pass
kids = non_abstract_children(AbstractBase)
assert Child1 in kids
assert Child2 in kids
assert GrandChild in kids
assert AbstractChild not in kids
def test_non_abstract_children():
from ctapipe.core import non_abstract_children
class AbstractBase(ABC):
@abstractmethod
def method(self):
pass
class Child1(AbstractBase):
def method(self):
print('method of Child1')
class Child2(AbstractBase):
def method(self):
print('method of Child2')
class GrandChild(Child2):
def method(self):
print('method of GrandChild')
class AbstractChild(AbstractBase):
pass
kids = non_abstract_children(AbstractBase)
assert Child1 in kids
assert Child2 in kids
assert GrandChild in kids
assert AbstractChild not in kids
def test_available_sources():
from ctapipe.io.eventsource import EventSource
from ctapipe.core import non_abstract_children
# make this before the explicit imports to make sure
# all classes are avaialble even if not explicitly imported
children = non_abstract_children(EventSource)
from ctapipe.io.simteleventsource import SimTelEventSource
assert SimTelEventSource in children
def enum_trait(base_class, default, help_str=None):
'''create a configurable CaselessStrEnum traitlet from baseclass
the enumeration should contain all names of non_abstract_children()
of said baseclass and the default choice should be given by
`base_class._default` name.
default must be specified and must be the name of one child-class
'''
if help_str is None:
help_str = '{} to use.'.format(base_class.__name__)
choices = [cls.__name__ for cls in non_abstract_children(base_class)]
if default not in choices:
raise ValueError('{default} is not in choices: {choices}'.format(
default=default,
choices=choices,
))
return CaselessStrEnum(choices, default, allow_none=True,
help=help_str).tag(config=True)
from traitlets.config.loader import Config
from ctapipe.core import non_abstract_children
from ctapipe.image.extractor import (
extract_around_peak,
neighbor_average_waveform,
subtract_baseline,
integration_correction,
ImageExtractor,
FixedWindowSum,
NeighborPeakWindowSum,
)
from ctapipe.image.toymodel import WaveformModel
from ctapipe.instrument import SubarrayDescription, TelescopeDescription
extractors = non_abstract_children(ImageExtractor)
# FixedWindowSum has no peak finding and need to be set manually
extractors.remove(FixedWindowSum)
@pytest.fixture(scope="module")
def subarray():
subarray = SubarrayDescription(
"test array",
tel_positions={
1: np.zeros(3) * u.m,
2: np.zeros(3) * u.m
},
tel_descriptions={
1:
TelescopeDescription.from_name(optics_name="SST-ASTRI",
from ctapipe.core import non_abstract_children
from ctapipe.image.extractor import (
extract_around_peak,
neighbor_average_waveform,
subtract_baseline,
integration_correction,
ImageExtractor,
FixedWindowSum,
NeighborPeakWindowSum,
TwoPassWindowSum,
)
from ctapipe.image.toymodel import WaveformModel
from ctapipe.instrument import SubarrayDescription, TelescopeDescription
extractors = non_abstract_children(ImageExtractor)
# FixedWindowSum has no peak finding and need to be set manually
extractors.remove(FixedWindowSum)
@pytest.fixture(scope="module")
def subarray():
subarray = SubarrayDescription(
"test array",
tel_positions={
1: np.zeros(3) * u.m,
2: np.zeros(3) * u.m
},
tel_descriptions={
1:
TelescopeDescription.from_name(optics_name="SST-ASTRI",
from sstcam_simulation import Photoelectrons, SSTCameraMapping
from sstcam_simulation.camera.spe import single_gaussian, sipm_gentile_spe, \
SPESpectrum, optical_crosstalk_probability, SiPMDelayed, SiPMReflectedOCT
from ctapipe.core import non_abstract_children
import numpy as np
import pytest
subclasses = non_abstract_children(SPESpectrum)
subclasses.remove(SiPMReflectedOCT)
def test_pmt():
x = np.linspace(0, 3, 10000)
pdf = single_gaussian(x, 0.2)
avg = np.average(x, weights=pdf)
var = np.average((x - avg)**2, weights=pdf)
np.testing.assert_allclose(avg, 1, rtol=1e-5)
np.testing.assert_allclose(var, 0.04, rtol=1e-5)
def test_optical_crosstalk_probability():
k = 1
assert optical_crosstalk_probability(k, 0.3) == 1 - 0.3
k = np.arange(1, 250)
assert optical_crosstalk_probability(k, 0.2).sum() == 1
assert optical_crosstalk_probability(0, 0.3) == 0
@pytest.mark.parametrize("opct", [0.1, 0.3, 0.5, 0.7, 0.9])
def classes_with_traits(base_class):
all_classes = [base_class] + non_abstract_children(base_class)
return [cls for cls in all_classes if has_traits(cls)]
def classes_with_traits(base_class):
all_classes = [base_class] + non_abstract_children(base_class)
return [cls for cls in all_classes if has_traits(cls)]
