def test_augment_observation(test_file, test_file_uri):
test_fitsparser = FitsParser(test_file)
test_obs = Observation('collection', 'observation_id',
Algorithm('algorithm'))
test_fitsparser.augment_observation(test_obs, test_file_uri)
assert test_obs is not None
assert test_obs.planes is not None
assert len(test_obs.planes) == 1
test_plane = test_obs.planes['HI-line']
assert test_plane.artifacts is not None
assert len(test_plane.artifacts) == 1
test_artifact = test_plane.artifacts[test_file_uri]
assert test_artifact is not None
test_part = test_artifact.parts['0']
# remove the chunk bit, as it's part of other tests -
# results in <caom2:chunks/> xml output
test_part.chunks.pop()
# set the ids to expected values
test_obs._id = uuid.UUID('00000000000000001234567812345678')
test_plane._id = uuid.UUID('00000000000000001234567812345678')
test_artifact._id = uuid.UUID('00000000000000001234567812345678')
test_part._id = uuid.UUID('00000000000000001234567812345678')
output = BytesIO()
ow = ObservationWriter(False, False, "caom2",
obs_reader_writer.CAOM20_NAMESPACE)
ow.write(test_obs, output)
result = output.getvalue().decode('UTF-8')
output.close()
assert result == EXPECTED_OBS_XML # , result
def test_augment_artifact_position_from_blueprint():
test_blueprint = ObsBlueprint(position_axes=(1, 2))
test_blueprint.set('Chunk.positionAxis1', '1')
test_blueprint.set('Chunk.positionAxis2', '2')
test_blueprint.set('Chunk.position.axis.axis1.ctype', 'GLON-CAR')
test_blueprint.set('Chunk.position.axis.axis1.cunit', 'deg')
test_blueprint.set('Chunk.position.axis.axis2.ctype', 'GLAT-CAR')
test_blueprint.set('Chunk.position.axis.axis2.cunit', 'deg')
test_blueprint.set('Chunk.position.axis.function.cd11', '-0.004999999')
test_blueprint.set('Chunk.position.axis.function.cd12', '0.0')
test_blueprint.set('Chunk.position.axis.function.cd21', '0.0')
test_blueprint.set('Chunk.position.axis.function.cd22', '0.004999999')
test_blueprint.set('Chunk.position.axis.function.dimension.naxis1', '1')
test_blueprint.set('Chunk.position.axis.function.dimension.naxis2', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord1.pix', '513.0')
test_blueprint.set('Chunk.position.axis.range.start.coord1.val',
'128.7499990027')
test_blueprint.set('Chunk.position.axis.range.start.coord2.pix', '513.0')
test_blueprint.set('Chunk.position.axis.range.start.coord2.val',
'-0.9999999922536')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='test_parser')
test_chunk = Chunk()
test_fitsparser._try_position_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_POSITION_XML,
ObservationReader()._get_spatial_wcs, 'position')
result = get_differences(ex, test_chunk.position)
assert result is None
def test_augment_polarization(test_file):
test_fitsparser = FitsParser(test_file, ObsBlueprint(polarization_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
polarization = artifact.parts['0'].chunks[0].polarization
check_xml(ObservationWriter()._add_polarization_wcs_element, polarization,
EXPECTED_POLARIZATION_XML)
def test_augment_energy(test_file):
test_fitsparser = FitsParser(test_file)
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
energy = artifact.parts['0'].chunks[0].energy
energy.bandpassName = '21 cm' # user set attribute
check_xml(ObservationWriter()._add_spectral_wcs_element, energy,
EXPECTED_ENERGY_XML)
def test_augment_energy():
bp = ObsBlueprint(energy_axis=1)
test_fitsparser = FitsParser(sample_file_4axes, bp)
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
energy = artifact.parts['0'].chunks[0].energy
ex = _get_from_str_xml(EXPECTED_ENERGY_XML,
ObservationReader()._get_spectral_wcs, 'energy')
result = get_differences(ex, energy)
assert result is None, repr(energy)
def test_augment_polarization():
test_fitsparser = FitsParser(sample_file_4axes,
ObsBlueprint(polarization_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
polarization = artifact.parts['0'].chunks[0].polarization
ex = _get_from_str_xml(EXPECTED_POLARIZATION_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
result = get_differences(ex, polarization)
assert result is None, result
def test_augment_artifact_time(test_file, expected):
test_fitsparser = FitsParser(test_file, ObsBlueprint(time_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 6
test_part = artifact.parts['1']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.time is not None
check_xml(ObservationWriter()._add_temporal_wcs_element, test_chunk.time,
expected)
def test_augment_artifact(test_file):
test_fitsparser = FitsParser(test_file, ObsBlueprint(position_axis=(1, 2)))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 1
test_part = artifact.parts['0']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.position is not None
check_xml(ObservationWriter()._add_spatial_wcs_element,
test_chunk.position, EXPECTED_POSITION_XML)
def test_augment_artifact():
test_blueprint = ObsBlueprint(position_axes=(1, 2))
test_fitsparser = FitsParser(sample_file_4axes, test_blueprint)
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 1
test_part = artifact.parts['0']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.position is not None
ex = _get_from_str_xml(EXPECTED_POSITION_XML,
ObservationReader()._get_spatial_wcs, 'position')
result = get_differences(ex, test_chunk.position)
assert result is None
def test_augment_artifact_time():
test_fitsparser = FitsParser(sample_file_time_axes,
ObsBlueprint(time_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_time_axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 6
test_part = artifact.parts['1']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.time is not None
ex = _get_from_str_xml(EXPECTED_CFHT_WIRCAM_RAW_GUIDE_CUBE_TIME,
ObservationReader()._get_temporal_wcs, 'time')
result = get_differences(ex, test_chunk.time)
assert result is None
def test_augment_observation():
test_obs_blueprint = ObsBlueprint(position_axes=(1, 2))
test_obs_blueprint.set('Observation.target.name', 'CGPS Mosaic MA1')
test_obs_blueprint.set('Observation.target.standard', False)
test_obs_blueprint.set('Observation.telescope.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.instrument.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.telescope.geoLocationX',
'-2100330.87517')
test_obs_blueprint.set('Observation.telescope.geoLocationY',
'-3694247.82445')
test_obs_blueprint.set('Observation.telescope.geoLocationZ',
'4741018.33097')
test_obs_blueprint.set('Plane.dataProductType', 'cube')
test_obs_blueprint.set('Artifact.productType', 'info')
test_obs_blueprint.set('Artifact.releaseType', 'data')
test_obs_blueprint.set('Plane.calibrationLevel', '2')
test_fitsparser = FitsParser(sample_file_4axes_obs, test_obs_blueprint)
test_fitsparser.blueprint = test_obs_blueprint
test_obs = SimpleObservation('collection', 'MA1_DRAO-ST',
Algorithm('exposure'))
test_fitsparser.augment_observation(test_obs,
sample_file_4axes_uri,
product_id='HI-line')
assert test_obs is not None
assert test_obs.planes is not None
assert len(test_obs.planes) == 1
test_plane = test_obs.planes['HI-line']
assert test_plane.artifacts is not None
assert len(test_plane.artifacts) == 1
test_artifact = test_plane.artifacts[sample_file_4axes_uri]
assert test_artifact is not None
test_part = test_artifact.parts['0']
# remove the chunk bit, as it's part of other tests -
# results in <caom2:chunks/> xml output
test_part.chunks.pop()
output = BytesIO()
ow = ObservationWriter(False, False, "caom2",
obs_reader_writer.CAOM20_NAMESPACE)
ow.write(test_obs, output)
result = output.getvalue().decode('UTF-8')
output.close()
expected = _get_obs(EXPECTED_OBS_XML)
actual = _get_obs(result)
diff_result = get_differences(expected, actual, 'Observation')
assert diff_result is None
def test_augment_artifact_polarization_from_blueprint():
test_blueprint = ObsBlueprint(polarization_axis=1)
test_blueprint.set('Chunk.polarizationAxis', '1')
test_blueprint.set('Chunk.polarization.axis.axis.ctype', 'STOKES')
test_blueprint.set('Chunk.polarization.axis.function.refCoord.pix', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.refCoord.val', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.delta', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='test_parser')
test_chunk = Chunk()
test_fitsparser._try_polarization_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_POLARIZATION_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
result = get_differences(ex, test_chunk.polarization)
assert result is None
def test_augment_artifact_energy_from_blueprint():
test_blueprint = ObsBlueprint(energy_axis=1)
test_blueprint.set('Chunk.energyAxis', 1)
test_blueprint.set('Chunk.energy.specsys', 'LSRK')
test_blueprint.set('Chunk.energy.axis.axis.ctype', 'VRAD')
test_blueprint.set('Chunk.energy.axis.axis.cunit', 'm / s')
test_blueprint.set('Chunk.energy.axis.function.refCoord.pix', '145.0')
test_blueprint.set('Chunk.energy.axis.function.refCoord.val', '-60000.0')
test_blueprint.set('Chunk.energy.axis.function.delta', '-824.46002')
test_blueprint.set('Chunk.energy.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_fitsparser._try_energy_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_ENERGY_XML,
ObservationReader()._get_spectral_wcs, 'energy')
result = get_differences(ex, test_chunk.energy)
assert result is None
def test_augment_observation(test_file, test_file_uri):
# logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
test_obs_blueprint = ObsBlueprint(position_axis=(1, 2))
test_obs_blueprint.set('Observation.target.name', 'CGPS Mosaic MA1')
test_obs_blueprint.set('Observation.telescope.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.instrument.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.telescope.geoLocationX',
'-2100330.87517')
test_obs_blueprint.set('Observation.telescope.geoLocationY',
'-3694247.82445')
test_obs_blueprint.set('Observation.telescope.geoLocationZ',
'4741018.33097')
test_obs_blueprint.set('Plane.dataProductType', 'cube')
test_obs_blueprint.set('Plane.calibrationLevel', '2')
test_fitsparser = FitsParser(test_file, test_obs_blueprint)
test_fitsparser.blueprint = test_obs_blueprint
test_obs = Observation('collection', 'MA1_DRAO-ST', Algorithm('exposure'))
test_fitsparser.augment_observation(test_obs,
test_file_uri,
product_id='HI-line')
assert test_obs is not None
assert test_obs.planes is not None
assert len(test_obs.planes) == 1
test_plane = test_obs.planes['HI-line']
assert test_plane.artifacts is not None
assert len(test_plane.artifacts) == 1
test_artifact = test_plane.artifacts[test_file_uri]
assert test_artifact is not None
test_part = test_artifact.parts['0']
# remove the chunk bit, as it's part of other tests -
# results in <caom2:chunks/> xml output
test_part.chunks.pop()
output = BytesIO()
ow = ObservationWriter(False, False, "caom2",
obs_reader_writer.CAOM20_NAMESPACE)
ow.write(test_obs, output)
result = output.getvalue().decode('UTF-8')
output.close()
compare = re.sub(r'caom2:id=".*"', 'caom2:id=""', result)
assert compare == EXPECTED_OBS_XML # , result
def add_headers_to_obs_by_blueprint(obs, headers, blueprint, uri, product_id):
"""
Common code that puts together knowledge of the blueprint and the
FitsParser to add information to an Observation.
:param obs Observation to be added to
:param headers astropy FITS headers with in-coming metadata
:param blueprint caom2utils.ObsBlueprint instance to map from the
metadata to the CAOM structure
:param uri Artifact URI to add to Observation instance
:param product_id Plane identifier, to know which plane to add
"""
parser = FitsParser(headers, blueprint, uri)
parser.augment_observation(obs, uri, product_id)
# re-home the chunk information to be consistent with accepted CAOM
# patterns of part/chunk relationship - i.e. part 0 never has chunks
# if the file being represented has extensions. This
# relationship gets missed when only using the headers[1:], so
# shift all the chunks up by one, and set the 0th to no chunks
for plane in obs.planes.values():
if plane.product_id != product_id:
continue
for artifact in plane.artifacts.values():
if artifact.uri == uri and len(artifact.parts) > 1:
first_index = None
prev_chunks = None
for key, value in artifact.parts.items():
if first_index is None:
first_index = key
prev_chunks = value.chunks
continue
else:
temp = value.chunks
value.chunks = prev_chunks
prev_chunks = temp
artifact.parts['0'].chunks = TypedList(Chunk, )
def test_visit():
test_obs = _get_obs(EXPECTED_FILE_SCHEME_XML)
with pytest.raises(ImportError):
_load_plugin('nonexistent.py')
with pytest.raises(ImportError):
_load_plugin(non_conformant_plugin_module)
test_fitsparser = FitsParser(sample_file_4axes,
ObsBlueprint(polarization_axis=1))
kwargs = {}
_visit(test_plugin_module, test_fitsparser, test_obs, **kwargs)
_visit(test_class_plugin_module, test_fitsparser, test_obs, **kwargs)
def test_augment_artifact_time_from_blueprint():
test_blueprint = ObsBlueprint(time_axis=1)
test_blueprint.set('Chunk.timeAxis', '1')
test_blueprint.set('Chunk.time.exposure', '0.02')
test_blueprint.set('Chunk.time.resolution', '0.02')
test_blueprint.set('Chunk.time.timesys', 'UTC')
test_blueprint.set('Chunk.time.axis.axis.ctype', 'TIME')
test_blueprint.set('Chunk.time.axis.axis.cunit', 'd')
test_blueprint.set('Chunk.time.axis.error.syser', '1e-07')
test_blueprint.set('Chunk.time.axis.error.rnder', '1e-07')
test_blueprint.set('Chunk.time.axis.function.refCoord.pix', '0.5')
test_blueprint.set('Chunk.time.axis.function.refCoord.val',
'56789.4298069')
test_blueprint.set('Chunk.time.axis.function.delta', '2.31481e-07')
test_blueprint.set('Chunk.time.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_fitsparser._try_time_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_CFHT_WIRCAM_RAW_GUIDE_CUBE_TIME,
ObservationReader()._get_temporal_wcs, 'time')
result = get_differences(ex, test_chunk.time)
assert result is None
def test_chunk_naxis():
hdr1 = fits.Header()
test_blueprint = ObsBlueprint()
test_blueprint.configure_time_axis(3)
test_uri = 'ad:CFHT/1709071g.fits.gz'
test_defaults = {'CTYPE3': 'TIME'}
test_config = {'Chunk.naxis': 'chunk.naxis'}
test_overrides = {'chunk.naxis': '1'}
update_blueprint(test_blueprint,
test_uri,
config=test_config,
defaults=test_defaults,
overrides=test_overrides)
assert test_blueprint._get('Chunk.naxis') == '1', 'default value assigned'
FitsParser([hdr1], test_blueprint)
assert hdr1['NAXIS'] == 1
assert hdr1['ZNAXIS'] == 1
def visit(self):
for uri, file_info in self._metadata_reader.file_info.items():
headers = self._metadata_reader.headers.get(uri)
telescope_data = Telescope(uri, headers)
blueprint = ObsBlueprint(instantiated_class=telescope_data)
telescope_data.accumulate_bp(blueprint)
if len(headers) == 0:
parser = GenericParser(blueprint, uri)
else:
parser = FitsParser(headers, blueprint, uri)
if self._dump_config:
print(f'Blueprint for {uri}: {blueprint}')
if self._observation is None:
if blueprint._get('DerivedObservation.members') is None:
self._logger.debug('Build a SimpleObservation')
self._observation = SimpleObservation(
collection=self._storage_name.collection,
observation_id=self._storage_name.obs_id,
algorithm=Algorithm('exposure'),
)
else:
self._logger.debug('Build a DerivedObservation')
self._observation = DerivedObservation(
collection=self._storage_name.collection,
observation_id=self._storage_name.obs_id,
algorithm=Algorithm('composite'),
)
parser.augment_observation(
observation=self._observation,
artifact_uri=uri,
product_id=self._storage_name.product_id,
)
self._observation = telescope_data.update(self._observation,
self._storage_name,
file_info)
return self._observation
def test_update_fits_headers():
# The rules for the values:
# all upper case - a FITS keyword
# has an '{' or an '}' - a FITS keyword with an index
#
# The rules for the keys:
# has a '.' - a config keyword
# all upper case - a FITS keyword
hdr1 = fits.Header()
hdr2 = fits.Header()
hdr3 = fits.Header()
hdr4 = fits.Header()
hdr5 = fits.Header()
hdr6 = fits.Header()
hdr7 = fits.Header()
test_blueprint = ObsBlueprint()
test_blueprint.configure_time_axis(3)
test_parser = FitsParser(src=[hdr1, hdr2, hdr3, hdr4, hdr5, hdr6, hdr7])
test_uri = 'ad:CFHT/1709071g.fits.gz'
update_blueprint(test_blueprint,
test_uri,
config={},
defaults={},
overrides={})
assert test_parser.blueprint._get('Observation.type') == \
(['OBSTYPE'], None), 'unmodified blueprint'
test_defaults = {
'CTYPE1': 'RA---TAN',
'CTYPE2': 'DEC--TAN',
'CTYPE3': 'TIME',
'CTYPE4': 'WAVE',
'CDELT4': '1.2',
'CRVAL4': '32'
}
update_blueprint(test_blueprint,
test_uri,
config={},
defaults=test_defaults,
overrides={})
assert test_blueprint._get('Chunk.position.axis.axis1.ctype') == \
(['CTYPE1'], 'RA---TAN'), 'default value assigned'
assert test_blueprint._get('Chunk.position.axis.axis2.ctype') == \
(['CTYPE2'], 'DEC--TAN'), 'default value assigned'
assert test_blueprint._get('Chunk.time.axis.axis.ctype') == \
(['CTYPE3'], 'TIME'), 'default value assigned, value all upper case'
# print(test_parser.blueprint)
test_defaults = {
'CTYPE1': 'RA--TAN',
'CTYPE2': 'DEC--TAN',
'CTYPE3': 'TIME',
'plane.dataProductType': 'image',
'provenance.producer': 'CFHT',
'provenance.project': 'STANDARD PIPELINE'
}
test_config = load_config(java_config_file)
test_overrides = load_config(override_file)
update_blueprint(test_blueprint, test_uri, test_config, test_defaults,
test_overrides)
assert test_blueprint._get('Plane.dataProductType') == \
'image', 'default value assigned to configuration'
assert test_blueprint._get('Plane.provenance.producer') == \
(['ORIGIN'], 'CFHT'), \
'default value assigned to configuration, all upper-case'
assert test_blueprint._get('Plane.provenance.project') == \
(['ADC_ARCH'], 'STANDARD PIPELINE'), \
'default value assigned to configuration, with white-space'
assert test_blueprint._get('Observation.type') == 'OBJECT', \
'default value over-ridden, value all upper case'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
0) == '210.551666667', 'override HDU 0'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val', 1) == \
'210.551666667', 'override HDU 1'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
2) == '210.508333333', 'override HDU 2'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
3) == '210.898333333', 'override HDU 3'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
4) == '210.942083333', 'override HDU 4'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
5) == '0.000000000', 'override HDU 5'
test_parser.blueprint = test_blueprint
assert test_parser._headers[0]['CRVAL1'] == 210.551666667, 'override HDU 0'
assert test_parser._headers[1]['CRVAL1'] == 210.551666667, 'override HDU 1'
assert test_parser._headers[2]['CRVAL1'] == 210.508333333, 'override HDU 2'
assert test_parser._headers[3]['CRVAL1'] == 210.898333333, 'override HDU 3'
assert test_parser._headers[4]['CRVAL1'] == 210.942083333, 'override HDU 4'
assert test_parser._headers[5]['CRVAL1'] == 0.000000000, 'override HDU 5'
assert test_parser._headers[0][
'CRVAL3'] == 56789.429806900000, 'override HDU 0'
# this will fail because of CompositeObservation.members errors
assert len(test_parser._errors) == 0, test_parser._errors
def test_get_from_list():
test_fitsparser = FitsParser(sample_file_4axes)
test_fitsparser.blueprint = ObsBlueprint()
result = test_fitsparser._get_from_list('Observation.intent', 0,
ObservationIntentType.SCIENCE)
assert result == ObservationIntentType.SCIENCE
def test_get_from_list(test_file):
test_fitsparser = FitsParser(test_file)
result = test_fitsparser._get_from_list('Observation.intent', 0,
ObservationIntentType.SCIENCE)
assert result == ObservationIntentType.SCIENCE
def test_augment_artifact_bounds_range_from_blueprint():
test_blueprint = ObsBlueprint(energy_axis=1,
time_axis=2,
polarization_axis=3,
position_axes=(4, 5))
test_blueprint.set('Chunk.energy.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.energy.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.energy.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.energy.axis.range.end.val', '1')
test_blueprint.set('Chunk.time.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.time.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.time.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.time.axis.range.end.val', '1')
test_blueprint.set('Chunk.polarization.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.polarization.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.polarization.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.polarization.axis.range.end.val', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord1.pix', '145.0')
test_blueprint.set('Chunk.position.axis.range.start.coord1.val',
'-60000.0')
test_blueprint.set('Chunk.position.axis.range.end.coord1.pix',
'-824.46002')
test_blueprint.set('Chunk.position.axis.range.end.coord1.val', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord2.pix', '145.0')
test_blueprint.set('Chunk.position.axis.range.start.coord2.val',
'-60000.0')
test_blueprint.set('Chunk.position.axis.range.end.coord2.pix',
'-824.46002')
test_blueprint.set('Chunk.position.axis.range.end.coord2.val', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_chunk.energy = SpectralWCS(CoordAxis1D(Axis('WAVE', 'm')), 'TOPOCENT')
test_chunk.time = TemporalWCS(CoordAxis1D(Axis('TIME', 'd')))
test_chunk.polarization = PolarizationWCS(CoordAxis1D(Axis('STOKES')))
test_chunk.position = SpatialWCS(
CoordAxis2D(Axis('RA', 'deg'), Axis('DEC', 'deg')))
test_fitsparser._try_range_with_blueprint(test_chunk, 0)
assert test_chunk.energy.axis.range is not None, \
'chunk.energy.axis.range should be declared'
assert test_chunk.time.axis.range is not None, \
'chunk.time.axis.range should be declared'
assert test_chunk.polarization.axis.range is not None, \
'chunk.polarization.axis.range should be declared'
assert test_chunk.position.axis.range is not None, \
'chunk.position.axis.range should be declared'
ex = _get_from_str_xml(EXPECTED_ENERGY_RANGE_BOUNDS_XML,
ObservationReader()._get_spectral_wcs, 'energy')
assert ex is not None, \
'energy string from expected output should be declared'
result = get_differences(ex, test_chunk.energy)
assert result is None
ex = _get_from_str_xml(EXPECTED_TIME_RANGE_BOUNDS_XML,
ObservationReader()._get_temporal_wcs, 'time')
assert ex is not None, \
'time string from expected output should be declared'
result = get_differences(ex, test_chunk.time)
assert result is None
ex = _get_from_str_xml(EXPECTED_POL_RANGE_BOUNDS_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
assert ex is not None, \
'polarization string from expected output should be declared'
result = get_differences(ex, test_chunk.polarization)
assert result is None
ex = _get_from_str_xml(EXPECTED_POS_RANGE_BOUNDS_XML,
ObservationReader()._get_spatial_wcs, 'position')
assert ex is not None, \
'position string from expected output should be declared'
result = get_differences(ex, test_chunk.position)
assert result is None
