hera-team / bda_utils Goto Github PK

We want to change some of the values in xgpu_info.h. We want:

• NTIME_PIPE = 16
• NTIME = 16*157

This will help with the LST alignment requirements.

The hera_gpu_bda thread must respect the LST integration boundaries defined by our LST grid. This probably boils down to choosing xeng:intstart correctly and making sure it's the right number. This should be the coarsest resolution of our BDA grid so that LST alignment is "easy" to do.

We need code that will determine the phase center for each antenna during the integration window. This maps into phasors that we upload to the F-engines. I have some code that will do this, I will add it to the repo.

There are some inter-related dependencies for bringing the system up, especially related to BDA and the LST gridding. We must define what happens in what order, and have a user-friendly way of running the steps in the correct order (a la Makefile).

We want to make sure that the following keys are added to redis by the feng_init.py script during F-engine arming.

• feng:samples_per_mcnt
• feng:sample_freq
• feng:sync_time

The mapping between X-engine inputs and antennas is coded in the corr:map redis key. We want to make sure that when this is updated, the catcher:bda_config redis key is blown away so that there is no internal inconsistency.

Make sure that the xeng:intstart value is appropriate subtracted off from the mcnt so that LST integration boundaries are being respected.

xeng:intstart in redis is the starting mcnt for an integration. This key should be populated by hera_control.py as part of startup. This seems to start the integration on the X-engines.

We want to propagate NTIME compile-time constant from xgpu_info.h into redis as xeng:ntime. Looks like xtor_up.py should be the place to do this. This might also be able to be done using the hashpipe-redis gateway. We need to know the value of this constant, so some process has to populate redis.

Make a script hera_create_bda_config.py which will set the following redis keys:

• catcher:ngrid (total number of LST bins in a night--tentatively 2726)
• catcher:bda_config (number of GPU blocks per baseline). This is derived from corr:map. If this key does not exist, this script should populate it. This is the mapping of an antenna pair into a tier.
• catcher:latitude (radians)
• catcher:longitude (radians)
• catcher:tier_to_time (the mapping of correlator averaging tier into an integration time)

hera_catcher_up.py sets catcher:bcnt_max redis key. This is the number of packets in an integration. The disk thread needs this number. Presumably this is derived from catcher:bda_config. This depends on the number of baselines falling into a particular tier of the bda_config.

We want to support adding 339.8 Hz to the current clock frequency of 500 MHz. This will enable us to have ~perfect LST alignment over the course of an observing day. It looks like this is working as part of bench testing, so we want to support implementing this.

Right now there is a separate script that will make a template file which is used by the catcher for all data files. We may not need this template file, so we should figure out what information is needed and whether it can be handled entirely internally to the catcher.

The NPKTS_PER_INT parameter needs to be set to a particular magic value. This value is defined in the LST-BDA memo. This value pairs with NGRID. It's probably 384, but we should verify this.