def _get_configs(self):
super()._close_opened_smd_files()
self.smd_fds = np.array([os.open(smd_file, os.O_RDONLY) for smd_file in self.smd_files], dtype=np.int32)
logger.debug(f'legion_ds: opened smd_fds: {self.smd_fds}')
self.smdr_man = SmdReaderManager(self.smd_fds, self.dsparms)
# Reading configs (first dgram of the smd files)
return self.smdr_man.get_next_dgrams()
def _apply_detector_selection(self):
"""
Handles two arguments
1) detectors=[detname,]
Reduce no. of smd/xtc files to only those with selectec detectors
2) small_xtc=[detname,]
Swap out smd files with these given detectors with bigdata files
"""
use_smds = [False] * len(self.smd_files)
if self.detectors or self.small_xtc:
# Get tmp configs using SmdReader
# this smd_fds, configs, and SmdReader will not be used later
smd_fds = np.array([os.open(smd_file, os.O_RDONLY) for smd_file in self.smd_files], dtype=np.int32)
logger.debug(f'ds_base: smd0 opened tmp smd_fds: {smd_fds}')
smdr_man = SmdReaderManager(smd_fds, self.dsparms)
all_configs = smdr_man.get_next_dgrams()
xtc_files = []
smd_files = []
configs = []
if self.detectors:
s1 = set(self.detectors)
for i, config in enumerate(all_configs):
if s1.intersection(set(config.software.__dict__.keys())):
if self.xtc_files: xtc_files.append(self.xtc_files[i])
if self.smd_files: smd_files.append(self.smd_files[i])
configs.append(config)
msg = f"""ds_base: applying detector selection
selected detectors: {self.detectors}
smd_files n_selected/n_total: {len(smd_files)}/{len(self.smd_files)}
{','.join([os.path.basename(smd_file) for smd_file in smd_files])}
xtc_files n_selected/n_total: {len(xtc_files)}/{len(self.xtc_files)}
{','.join([os.path.basename(xtc_file) for xtc_file in xtc_files])}
"""
logger.debug(msg)
else:
xtc_files = self.xtc_files[:]
smd_files = self.smd_files[:]
configs = all_configs
use_smds = [False] * len(smd_files)
if self.small_xtc:
s1 = set(self.small_xtc)
msg = f"""ds_base: applying smd files swap
selected detectors: {self.small_xtc}\n"""
for i, config in enumerate(configs):
if s1.intersection(set(config.software.__dict__.keys())):
smd_files[i] = xtc_files[i]
use_smds[i] = True
msg += f' smd_files[{i}]={os.path.basename(smd_files[i])} use_smds[{i}]={use_smds[i]}\n'
logger.debug(msg)
self.xtc_files = xtc_files
self.smd_files = smd_files
for smd_fd in smd_fds:
os.close(smd_fd)
logger.debug(f"ds_base: close tmp smd fds:{smd_fds}")
self.dsparms.set_use_smds(use_smds)
def _setup_configs(self):
super()._close_opened_smd_files()
self.smd_fds = np.array([os.open(smd_file, os.O_RDONLY) for smd_file in self.smd_files], dtype=np.int32)
logger.debug(f'legion_ds: opened smd_fds: {self.smd_fds}')
self.smdr_man = SmdReaderManager(self.smd_fds, self.dsparms)
self._configs = self.smdr_man.get_next_dgrams()
super()._setup_det_class_table()
super()._set_configinfo()
def _apply_detector_selection(self):
if self.detectors:
s1 = set(self.detectors)
xtc_files = []
smd_files = []
smd_fds = []
configs = []
for i, config in enumerate(self._configs):
if s1.intersection(set(config.__dict__.keys())):
if self.xtc_files: xtc_files.append(self.xtc_files[i])
if self.smd_files:
smd_files.append(self.smd_files[i])
smd_fds.append(self.smd_fds[i])
configs.append(config)
print(f"self.xtc_files={self.xtc_files}")
print(f"xtc_files={xtc_files}")
print(f"self.smd_files={self.smd_files}")
print(f"smd_files={smd_files}")
if not (self.smd_files == smd_files
and self.xtc_files == xtc_files):
print("update all files")
self.xtc_files = xtc_files
self.smd_files = smd_files
self.smd_fds = np.array(smd_fds, dtype=np.int32)
self.smdr_man = SmdReaderManager(self.smd_fds,
self.dsparms,
configs=configs)
self._configs = configs
def run_smd0():
smd_dir = '/cds/data/drpsrcf/users/monarin/xtcdata/10M60n/xtcdata/smalldata'
#smd_dir = '/cds/data/drpsrcf/users/monarin/tmoc00118/xtc/smalldata'
filesize = 760057400
n_files = int(sys.argv[1])
filenames = [None] * n_files
for i in range(n_files):
filenames[i] = os.path.join(smd_dir,
f'data-r0001-s{str(i).zfill(2)}.smd.xtc2')
#filenames[i] = os.path.join(smd_dir,f'tmoc00118-r0463-s{str(i).zfill(3)}-c000.smd.xtc2')
#filenames[i] = os.path.join(smd_dir,f'tmolv9418-r0175-s{str(i).zfill(3)}-c000.smd.xtc2')
smd_fds = np.array(
[os.open(filename, os.O_DIRECT) for filename in filenames],
dtype=np.int32)
st = time.time()
prom_man = PrometheusManager(os.getpid())
dsparms = DsParms(
batch_size=1, # bigdata batch size
max_events=max_events,
filter=0,
destination=0,
prom_man=prom_man,
max_retries=0,
live=False,
found_xtc2_callback=0,
timestamps=np.empty(0, dtype=np.uint64))
smdr_man = SmdReaderManager(smd_fds[:n_files], dsparms)
for i_chunk in enumerate(smdr_man.chunks()):
if not smdr_man.got_events: break
found_endrun = smdr_man.smdr.found_endrun()
if found_endrun:
print(f'found EndRun')
break
print(f'total search time: {smdr_man.smdr.total_time}')
en = time.time()
processed_events = smdr_man.processed_events
print(
f"#Smdfiles: {n_files} #Events: {processed_events} Elapsed Time (s): {en-st:.2f} Rate (MHz): {processed_events/((en-st)*1e6):.2f} Bandwidth(GB/s):{filesize*n_files*1e-9/(en-st):.2f}"
)
def run_smd0():
filenames = glob.glob(
'/gpfs/alpine/scratch/monarin/chm137/data/.tmp/smalldata/*.xtc2')
fds = np.array([os.open(filename, os.O_RDONLY) for filename in filenames],
dtype=np.int32)
run = Run(fds)
smdr_man = SmdReaderManager(run)
run.configs = smdr_man.get_next_dgrams()
run.beginruns = smdr_man.get_next_dgrams(configs=run.configs)
st = time.time()
processed_events = 0
for i, chunk in enumerate(smdr_man.chunks()):
#for i, batch in enumerate(smdr_man):
processed_events += smdr_man.got_events
en = time.time()
print("#Events: %d Elapsed Time (s): %f Rate (MHz): %f" %
(processed_events, (en - st), processed_events / ((en - st) * 1e6)))
class LegionDataSource(DataSourceBase):
def __init__(self, *args, **kwargs):
super(LegionDataSource, self).__init__(**kwargs)
super()._setup_runnum_list()
self.runnum_list_index = 0
self.smd_fds = None
self._setup_run()
super()._start_prometheus_client()
def __del__(self):
super()._close_opened_smd_files()
super()._end_prometheus_client()
def _setup_configs(self):
super()._close_opened_smd_files()
self.smd_fds = np.array([os.open(smd_file, os.O_RDONLY) for smd_file in self.smd_files], dtype=np.int32)
logger.debug(f'legion_ds: opened smd_fds: {self.smd_fds}')
self.smdr_man = SmdReaderManager(self.smd_fds, self.dsparms)
self._configs = self.smdr_man.get_next_dgrams()
super()._setup_det_class_table()
super()._set_configinfo()
def _setup_run(self):
if self.runnum_list_index == len(self.runnum_list):
return False
runnum = self.runnum_list[self.runnum_list_index]
self.runnum_list_index += 1
super()._setup_run_files(runnum)
self._setup_configs()
self.dm = DgramManager(self.xtc_files, configs=self._configs)
return True
def _setup_beginruns(self):
""" Determines if there is a next run as
1) New run found in the same smalldata files
2) New run found in the new smalldata files
"""
dgrams = self.smdr_man.get_next_dgrams()
while dgrams is not None:
if dgrams[0].service() == TransitionId.BeginRun:
self.beginruns = dgrams
return True
dgrams = self.smdr_man.get_next_dgrams()
return False
def _start_run(self):
found_next_run = False
if self._setup_beginruns(): # try to get next run from current files
super()._setup_run_calibconst()
found_next_run = True
elif self._setup_run(): # try to get next run from next files
if self._setup_beginruns():
super()._setup_run_calibconst()
found_next_run = True
return found_next_run
def runs(self):
while self._start_run():
run = RunLegion(self, Event(dgrams=self.beginruns))
yield run