class PawprintXTile(db.Model):
__tablename__ = "PawprintXTile"
__table_args__ = (
db.UniqueConstraint('pawprint_id', 'tile_id',
name='_pawprint_tile_uc'),
)
statuses = db.Enum(
"raw", "pending", "sync", name="pawprint_x_tile_statuses")
id = db.Column(db.Integer, db.Sequence('pxt_id_seq'), primary_key=True)
pawprint_id = db.Column(
db.Integer, db.ForeignKey('Pawprint.id'), nullable=False)
pawprint = db.relationship(
"Pawprint", backref=db.backref("pxts"))
tile_id = db.Column(db.Integer, db.ForeignKey('Tile.id'), nullable=False)
tile = db.relationship("Tile", backref=db.backref("pxts"))
status = db.Column(statuses, default="raw")
def __repr__(self):
string = "<PXT '{}: {}'>"
return string.format(self.tile.name, self.pawprint.name)
class Simulated(db.Model):
"""Model for transients that are simulated"""
__tablename__ = "Simulated"
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.Float, nullable=False)
y = db.Column(db.Float, nullable=False)
app_mag = db.Column(db.Float, nullable=False)
flux = db.Column(db.Float, nullable=False)
image_id = db.Column(db.Integer, db.ForeignKey('Images.id'))
image = db.relationship('Images',
backref=db.backref('simulateds', order_by=id))
simage_id = db.Column(db.Integer, db.ForeignKey('SImages.id'))
simage = db.relationship('SImages',
backref=db.backref('simulateds', order_by=id))
scorrimage_id = db.Column(db.Integer, db.ForeignKey('SCorrImages.id'))
scorrimage = db.relationship('SCorrImages',
backref=db.backref('simulateds', order_by=id))
image_id_ois = db.Column(db.Integer, db.ForeignKey('ImagesOIS.id'))
image_ois = db.relationship('ImagesOIS',
backref=db.backref('simulateds', order_by=id))
image_id_hot = db.Column(db.Integer, db.ForeignKey('ImagesHOT.id'))
image_hot = db.relationship('ImagesHOT',
backref=db.backref('simulateds', order_by=id))
def __repr__(self):
return str(self.id)
class ClassificationXMasterSource(db.Model):
__tablename__ = "ClassificationXMasterSource"
__table_args__ = (
db.UniqueConstraint('classification_id', 'master_src_id',
name='_classification_master_src_uc'),
)
id = db.Column(db.Integer, db.Sequence('cxms_id_seq'), primary_key=True)
classification_id = db.Column(
db.Integer, db.ForeignKey('Classification.id'), nullable=False)
classification = db.relationship(
"Classification", backref=db.backref("cxms"))
master_src_id = db.Column(
db.Integer, db.ForeignKey('MasterSource.id'), nullable=False)
master_src = db.relationship(
"MasterSource", backref=db.backref("cxms"))
extra_data = db.Column(db.JSONType)
def __repr__(self):
string = "<CXMS '{}: {}'>"
return string.format(self.classification.name, str(self.master_src))
class Match(db.Model):
__tablename__ = "Match"
__table_args__ = (
db.UniqueConstraint('pawprint_src_id', 'master_src_id', 'tile_id',
name='_match_uc'),
)
id = db.Column(db.Integer, db.Sequence('match_id_seq'), primary_key=True)
band = db.Column(
db.Enum("k", "j", "h", name="match, bands"), index=True)
tile_id = db.Column(
db.Integer, db.ForeignKey('Tile.id'), index=True, nullable=False)
tile = db.relationship(
"Tile", backref=db.backref("matches"), lazy="joined")
master_src_id = db.Column(
db.Integer, db.ForeignKey('MasterSource.id'),
index=True, nullable=False)
master_src = db.relationship(
"MasterSource", backref=db.backref("matches"), lazy="joined")
master_src_order = db.Column(db.Integer)
master_src_ra = db.Column(db.Float)
master_src_dec = db.Column(db.Float)
pawprint_id = db.Column(
db.Integer, db.ForeignKey('Pawprint.id'), index=True, nullable=False)
pawprint = db.relationship(
"Pawprint", backref=db.backref("matches"), lazy="joined")
pawprint_src_id = db.Column(
db.Integer, db.ForeignKey('PawprintSource.id'),
index=True, nullable=False)
pawprint_src = db.relationship(
"PawprintSource", backref=db.backref("matches"), lazy="joined")
pawprint_src_order = db.Column(db.Integer)
pawprint_src_ra = db.Column(db.Float)
pawprint_src_dec = db.Column(db.Float)
pawprint_src_mag = db.Column(db.Float)
pawprint_src_mag_err = db.Column(db.Float)
pawprint_src_hjd = db.Column(db.Float, nullable=True)
pawprint_src_chip_nro = db.Column(db.Float)
pawprint_src_stel_cls = db.Column(db.Float)
pawprint_src_elip = db.Column(db.Float)
pawprint_src_pos_ang = db.Column(db.Float)
tile_id = db.Column(
db.Integer, db.ForeignKey('Tile.id'), index=True, nullable=False)
tile = db.relationship(
"Tile", backref=db.backref("matches"), lazy="joined")
def __repr__(self):
return u"<Match '{}->{}'>".format(self.master_src, self.pawprint_src)
class PawprintStackXTile(db.Model):
"""Relation between a pawprint-stack and a tile. Because the virca, overlap
some pawprints can be in two tiles
"""
__tablename__ = "PawprintStackXTile"
__table_args__ = (db.UniqueConstraint('pawprint_stack_id',
'tile_id',
name='_pawprint_tile_uc'), )
statuses = db.Enum("raw", "ready-to-match", "matched", name="pxt_statuses")
id = db.Column(db.Integer, db.Sequence('pxt_id_seq'), primary_key=True)
pawprint_stack_id = db.Column(db.Integer,
db.ForeignKey('PawprintStack.id'),
nullable=False)
pawprint_stack = db.relationship("PawprintStack",
backref=db.backref("pxts"))
tile_id = db.Column(db.Integer, db.ForeignKey('Tile.id'), nullable=False)
tile = db.relationship("Tile", backref=db.backref("pxts"))
_npy_filename = db.Column("npy_filename", db.Text)
matched_number = db.Column(db.Integer, nullable=True)
status = db.Column(statuses, default="raw")
def __repr__(self):
string = "<PXT '{}: {}'>"
return string.format(self.tile.name, self.pawprint_stack.name)
@property
def npy_file_path(self):
if self._npy_filename:
return os.path.join(settings.MATCHS_DIR, self.tile.name,
self._npy_filename)
def store_npy_file(self, arr):
self._npy_filename = "{}_{}.npy".format(self.tile.name,
self.pawprint_stack.name)
file_dir = os.path.dirname(self.npy_file_path)
if not os.path.isdir(file_dir):
os.makedirs(file_dir)
np.save(self.npy_file_path, arr)
def load_npy_file(self):
return np.load(self.npy_file_path)
class Statistics(db.Model):
__tablename__ = 'Statistics'
id = db.Column(db.Integer, primary_key=True)
name_id = db.Column(db.Integer,
db.ForeignKey('Name.id'),
nullable=False,
unique=True)
name = db.relationship("Name",
backref=db.backref("statistics"),
uselist=False)
mean_sepal_length = db.Column(db.Float, nullable=False)
mean_sepal_width = db.Column(db.Float, nullable=False)
mean_petal_length = db.Column(db.Float, nullable=False)
mean_petal_width = db.Column(db.Float, nullable=False)
min_sepal_length = db.Column(db.Float, nullable=False)
min_sepal_width = db.Column(db.Float, nullable=False)
min_petal_length = db.Column(db.Float, nullable=False)
min_petal_width = db.Column(db.Float, nullable=False)
max_sepal_length = db.Column(db.Float, nullable=False)
max_sepal_width = db.Column(db.Float, nullable=False)
max_petal_length = db.Column(db.Float, nullable=False)
max_petal_width = db.Column(db.Float, nullable=False)
def __repr__(self):
return "<Statistics of '{}'>".format(self.name.name)
class Combination(db.Model):
__tablename__ = 'Combination'
id = db.Column(db.Integer, primary_key=True)
calfile_id = db.Column(db.Integer, db.ForeignKey('CalFile.id'))
calfile = db.relationship("CalFile",
backref=db.backref('combinations', order_by=id))
mastercal_id = db.Column(db.Integer, db.ForeignKey('MasterCal.id'))
mastercal = db.relationship("MasterCal",
backref=db.backref('combinations',
order_by=id))
def __repr__(self):
return self.id
class Campaign(db.Model):
__tablename__ = 'Campaign'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.Text, nullable=True)
observatory_id = db.Column(db.Integer, db.ForeignKey('Observatory.id'))
observatory = db.relationship("Observatory",
backref=db.backref('campaigns', order_by=id))
ccd_id = db.Column(db.Integer, db.ForeignKey('CCD.id'))
ccd = db.relationship("CCD", backref=db.backref('campaigns', order_by=id))
def __repr__(self):
return self.name
class RealsHOT(db.Model):
__tablename__ = "RealsHOT"
id = db.Column(db.Integer, primary_key=True)
detected_id = db.Column(db.Integer, db.ForeignKey('DetectedHOT.id'))
detected = db.relationship('DetectedHOT',
backref=db.backref('true_pos_hot', order_by=id))
simulated_id = db.Column(db.Integer, db.ForeignKey('Simulated.id'))
simulated = db.relationship('Simulated',
backref=db.backref('true_pos_hot'),
order_by=id)
def __repr__(self):
return str(self.id)
class StateChange(db.Model):
__tablename__ = 'StateChange'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime(timezone=True))
modified_at = db.Column(db.DateTime(timezone=True))
count = db.Column(db.Integer)
path = db.Column(db.Text, nullable=True)
state_id = db.Column(db.Integer, db.ForeignKey('State.id'))
state = db.relationship("State",
backref=db.backref('statechanges', order_by=id))
pawprint_id = db.Column(db.Integer, db.ForeignKey('Pawprint.id'))
pawprint = db.relationship("Pawprint",
backref=db.backref('statechanges', order_by=id))
def __repr__(self):
return "{} ({})".format(repr(self.pawprint), repr(self.state))
class ImagesOIS(db.Model):
__tablename__ = "ImagesOIS"
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(100), nullable=False)
crossmatched = db.Column(db.Boolean, nullable=False)
refimage_id = db.Column(db.Integer, db.ForeignKey('RefImages.id'))
refimage = db.relationship('RefImages',
backref=db.backref('OISImages', order_by=id))
newimage_id = db.Column(db.Integer, db.ForeignKey('NewImages.id'))
newimage = db.relationship('NewImages',
backref=db.backref('OISImages', order_by=id))
exec_time = db.Column(db.Float, nullable=False)
def __repr__(self):
return self.path
class BogusOIS(db.Model):
__tablename__ = "BogusOIS"
id = db.Column(db.Integer, primary_key=True)
detected_id = db.Column(db.Integer, db.ForeignKey('DetectedOIS.id'))
detected = db.relationship('DetectedOIS',
backref=db.backref('true_neg_ois', order_by=id))
def __repr__(self):
return str(self.id)
class SUndetected(db.Model):
__tablename__ = "SUndetected"
id = db.Column(db.Integer, primary_key=True)
simulated_id = db.Column(db.Integer, db.ForeignKey('Simulated.id'))
simulated = db.relationship('Simulated',
backref=db.backref('false_neg_s', order_by=id))
def __repr__(self):
return str(self.id)
class Pawprint(db.Model):
__tablename__ = 'Pawprint'
id = db.Column(db.Integer, primary_key=True)
jd = db.Column(db.Float, nullable=False)
created_at = db.Column(db.DateTime(timezone=True))
observation_date = db.Column(db.DateTime(timezone=True))
modified_at = db.Column(db.DateTime(timezone=True))
simple = db.Column(db.String(8), nullable=True)
bitpix = db.Column(db.Integer, nullable=True)
naxis = db.Column(db.Integer, nullable=True)
naxis1 = db.Column(db.Integer, nullable=True)
naxis2 = db.Column(db.Integer, nullable=True)
bscale = db.Column(db.Float, nullable=True)
bzero = db.Column(db.Float, nullable=True)
exposure = db.Column(db.Float, nullable=True)
set_temp = db.Column(db.Float, nullable=True)
xpixsz = db.Column(db.Float, nullable=True)
ypixsz = db.Column(db.Float, nullable=True)
exptime = db.Column(db.Integer, nullable=False)
ccdtemp = db.Column(db.Float, nullable=True)
imagetype = db.Column(db.String(32), nullable=False)
targname = db.Column(db.String(40), nullable=True)
xbinning = db.Column(db.Integer, nullable=False)
ybinning = db.Column(db.Integer, nullable=False)
readoutm = db.Column(db.String(24), nullable=True)
object_ = db.Column(db.String(24), nullable=True)
observer = db.Column(db.String(48), nullable=True)
state_id = db.Column(db.Integer, db.ForeignKey('State.id'))
state = db.relationship("State",
backref=db.backref('pawprints', order_by=id))
campaign_id = db.Column(db.Integer, db.ForeignKey('Campaign.id'))
campaign = db.relationship("Campaign",
backref=db.backref('pawprints', order_by=id))
def __repr__(self):
return self.id
class Candidate(db.Model):
__tablename__ = 'Candidate'
PREDICTED_TYPES = [("real", "Real"), ("bogus", "Bogus")]
id = db.Column(db.Integer, primary_key=True)
ra = db.Column(db.Float, nullable=False)
dec = db.Column(db.Float, nullable=False)
mag = db.Column(db.Float, nullable=False)
mag_err = db.Column(db.Float, nullable=False)
predicted = db.Column(db.ChoiceType(PREDICTED_TYPES), nullable=True)
pawprint_id = db.Column(db.Integer, db.ForeignKey('Pawprint.id'))
pawprint = db.relationship("Pawprint",
backref=db.backref('candidates', order_by=id))
stack_id = db.Column(db.Integer, db.ForeignKey('Stack.id'))
stack = db.relationship("Stack",
backref=db.backref('candidates', order_by=id))
def __repr__(self):
return "({}, {})".format(self.ra, self.dec)
class Observation(db.Model):
__tablename__ = 'Observation'
id = db.Column(db.Integer, primary_key=True)
name_id = db.Column(db.Integer, db.ForeignKey('Name.id'), nullable=False)
name = db.relationship("Name", backref=db.backref("observations"))
sepal_length = db.Column(db.Float, nullable=False)
sepal_width = db.Column(db.Float, nullable=False)
petal_length = db.Column(db.Float, nullable=False)
petal_width = db.Column(db.Float, nullable=False)
class SCorrBogus(db.Model):
__tablename__ = "SCorrBogus"
id = db.Column(db.Integer, primary_key=True)
detected_id = db.Column(db.Integer, db.ForeignKey('SCorrDetected.id'))
detected = db.relationship('SCorrDetected',
backref=db.backref('true_neg_scorr',
order_by=id))
def __repr__(self):
return str(self.id)
class SDetected(db.Model):
__tablename__ = "SDetected"
id = db.Column(db.Integer, primary_key=True)
thresh = db.Column(db.Float, nullable=False)
npix = db.Column(db.Float, nullable=False)
tnpix = db.Column(db.Float, nullable=False)
xmin = db.Column(db.Float, nullable=False)
xmax = db.Column(db.Float, nullable=False)
ymin = db.Column(db.Float, nullable=False)
ymax = db.Column(db.Float, nullable=False)
x = db.Column(db.Float, nullable=False)
y = db.Column(db.Float, nullable=False)
x2 = db.Column(db.Float, nullable=False)
y2 = db.Column(db.Float, nullable=False)
xy = db.Column(db.Float, nullable=False)
errx2 = db.Column(db.Float, nullable=False)
erry2 = db.Column(db.Float, nullable=False)
errxy = db.Column(db.Float, nullable=False)
a = db.Column(db.Float, nullable=False)
b = db.Column(db.Float, nullable=False)
theta = db.Column(db.Float, nullable=False)
cxx = db.Column(db.Float, nullable=False)
cyy = db.Column(db.Float, nullable=False)
cxy = db.Column(db.Float, nullable=False)
cflux = db.Column(db.Float, nullable=False)
flux = db.Column(db.Float, nullable=False)
cpeak = db.Column(db.Float, nullable=False)
peak = db.Column(db.Float, nullable=False)
xcpeak = db.Column(db.Float, nullable=False)
ycpeak = db.Column(db.Float, nullable=False)
xpeak = db.Column(db.Float, nullable=False)
ypeak = db.Column(db.Float, nullable=False)
flag = db.Column(db.Float, nullable=False)
#MU_THRESHOLD = db.Column(db.Float, nullable=False)
#SNR_WIN = db.Column(db.Float, nullable=False)
DELTAX = db.Column(db.Float, nullable=False)
DELTAY = db.Column(db.Float, nullable=False)
RATIO = db.Column(db.Float, nullable=False)
ROUNDNESS = db.Column(db.Float, nullable=False)
PEAK_CENTROID = db.Column(db.Float, nullable=False)
IS_REAL = db.Column(db.Boolean, nullable=True)
image_id = db.Column(db.Integer, db.ForeignKey('SImages.id'))
image = db.relationship('SImages',
backref=db.backref('Sdetected_srcs', order_by=id))
def __repr__(self):
return '{}::{}'.format(self.image, self.id)
class NewImages(db.Model):
__tablename__ = "NewImages"
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(100), nullable=False)
object_id = db.Column(db.Integer, db.ForeignKey('Object.id'))
object = db.relationship('Object',
backref=db.backref('newimage', order_by=id))
def __repr__(self):
return self.path
class Source(db.Model):
__tablename__ = 'Source'
id = db.Column(db.Integer, primary_key=True)
ra = db.Column(db.Float, nullable=False)
dec = db.Column(db.Float, nullable=False)
mag = db.Column(db.Float, nullable=False)
mag_err = db.Column(db.Float, nullable=False)
class_source = db.Column(db.String, nullable=True)
pawprint_id = db.Column(db.Integer, db.ForeignKey('Pawprint.id'))
pawprint = db.relationship("Pawprint",
backref=db.backref('sources', order_by=id))
def __repr__(self):
return "({}, {})".format(self.ra, self.dec)
class LightCurve(db.Model):
__tablename__ = "LightCurve"
id = db.Column(
db.Integer, db.Sequence('lightcurve_id_seq'), primary_key=True)
source_id = db.Column(
db.Integer, db.ForeignKey('MasterSource.id'),
nullable=False, unique=True)
source = db.relationship(
"MasterSource", backref=db.backref("lightcurve"), uselist=False)
obs_number = db.Column(db.Integer)
pdm_period = db.Column(db.Float, nullable=True)
ls_period = db.Column(db.Float, nullable=True)
def __repr__(self):
return "<LightCurve '{}'>".format(repr(self.source))
class SCorrDetected(db.Model):
__tablename__ = "SCorrDetected"
id = db.Column(db.Integer, primary_key=True)
X_IMAGE = db.Column(db.Float, nullable=False)
Y_IMAGE = db.Column(db.Float, nullable=False)
SIGNIFICANCE = db.Column(db.Float, nullable=False)
IS_REAL = db.Column(db.Boolean, nullable=True)
image_id = db.Column(db.Integer, db.ForeignKey('SCorrImages.id'))
image = db.relationship('SCorrImages',
backref=db.backref('SCorrdetected_srcs',
order_by=id))
def __repr__(self):
return '{}::{}'.format(self.image, self.id)
class MasterSource(db.Model):
__tablename__ = "MasterSource"
__table_args__ = (
db.UniqueConstraint('tile_id', 'order', name='_tile_order_uc'),
)
id = db.Column(
db.Integer, db.Sequence('master_src_id_seq'), primary_key=True)
tile_id = db.Column(db.Integer, db.ForeignKey('Tile.id'), nullable=False)
tile = db.relationship("Tile", backref=db.backref("sources"))
order = db.Column(db.Integer, nullable=False)
ra_h = db.Column(db.Float, nullable=False)
dec_h = db.Column(db.Float, nullable=False)
ra_j = db.Column(db.Float, nullable=False)
dec_j = db.Column(db.Float, nullable=False)
ra_k = db.Column(db.Float, nullable=False)
dec_k = db.Column(db.Float, nullable=False)
x = db.Column(db.Float, nullable=True)
y = db.Column(db.Float, nullable=True)
z = db.Column(db.Float, nullable=True)
type = db.Column(db.String(255))
@classmethod
def conesearch(cls, ra, dec, radius):
x, y, z = SkyCoord(
ra=ra, dec=dec, unit="deg", frame="icrs"
).represent_as("cartesian").xyz.value
cos_r = np.cos(radius)
query = (cls.x * x + cls.y * y + cls.z * z) >= cos_r
return query
def __repr__(self):
return u"<MasterSource '{}[{}]'>".format(self.tile, self.order)
class PawprintSource(db.Model):
__tablename__ = "PawprintSource"
__table_args__ = (
db.UniqueConstraint('pawprint_id', 'order', name='_pawprint_order_uc'),
)
id = db.Column(
db.Integer, db.Sequence('pawprint_src_id_seq'), primary_key=True)
pawprint_id = db.Column(
db.Integer, db.ForeignKey('Pawprint.id'), nullable=False)
pawprint = db.relationship(
"Pawprint", backref=db.backref("pxt"))
order = db.Column(db.Integer, nullable=False)
ra_deg = db.Column(db.Float)
ra_h = db.Column(db.Float)
ra_m = db.Column(db.Float)
ra_s = db.Column(db.Float)
dec_deg = db.Column(db.Float)
dec_d = db.Column(db.Float)
dec_m = db.Column(db.Float)
dec_s = db.Column(db.Float)
pwp_x = db.Column(db.Float)
pwp_y = db.Column(db.Float)
mag = db.Column(db.Float)
mag_err = db.Column(db.Float)
chip_nro = db.Column(db.Float)
stel_cls = db.Column(db.Float)
elip = db.Column(db.Float)
pos_ang = db.Column(db.Float)
hjd = db.Column(db.Float, nullable=True)
def __repr__(self):
return u"<PawprintSource '{}[{}]'>".format(self.pawprint, self.order)
class LightCurves(db.Model):
"""Stores the sources of the tile and also their observations
inside a pawprint. This resume are stores inside an hdf5 for
eficient access
"""
__tablename__ = "LightCurves"
id = db.Column(db.Integer, db.Sequence('lc_id_seq'), primary_key=True)
tile_id = db.Column(db.Integer,
db.ForeignKey('Tile.id'),
nullable=False,
unique=True)
tile = db.relationship("Tile",
backref=db.backref("lcurves", uselist=False),
lazy='joined')
# ~ feats_version = db.Column(db.String(10), default="1.0")
_src_obs_counter = db.Column("src_obs_cnt", db.PickleType, nullable=True)
def __repr__(self):
return "<LightCurves of '{}'>".format(self.tile.name)
def _check_write(self, attr):
if self.tile.ready:
msg = "Tile {} are ready so the Lightcurve.{} is readonly"
raise AttributeError(msg.format(self.tile.name, attr))
def _set_cnt(self, ids):
cnt = Counter(ids)
gen = (e for e in cnt.items())
dtype = [("id", np.int64), ("cnt", int)]
self._src_obs_counter = np.fromiter(gen, dtype=dtype)
@property
def lc_path(self):
path = os.path.join(settings.LC_DIR, self.tile.name)
if not os.path.isdir(path):
os.makedirs(path)
return path
@property
def obs_counter(self):
return self._src_obs_counter
@property
def observations(self):
fname = "lc_obs_{}.npy".format(self.tile.name)
path = os.path.join(self.lc_path, fname)
if os.path.exists(path):
return np.load(path)
@observations.setter
def observations(self, arr):
self._check_write("observations")
self._set_cnt(arr["bm_src_id"])
fname = "lc_obs_{}.npy".format(self.tile.name)
path = os.path.join(self.lc_path, fname)
np.save(path, arr)
@property
def features(self):
fname = "features_{}.npy".format(self.tile.name)
path = os.path.join(self.lc_path, fname)
if os.path.exists(path):
return np.load(path)
@features.setter
def features(self, arr):
self._check_write("features")
fname = "features_{}.npy".format(self.tile.name)
path = os.path.join(self.lc_path, fname)
np.save(path, arr)
class DetectedHOT(db.Model):
__tablename__ = "DetectedHOT"
id = db.Column(db.Integer, primary_key=True)
NUMBER = db.Column(db.Integer, nullable=False)
FLUX_ISO = db.Column(db.Float, nullable=False)
FLUXERR_ISO = db.Column(db.Float, nullable=False)
MAG_ISO = db.Column(db.Float, nullable=False)
MAGERR_ISO = db.Column(db.Float, nullable=False)
FLUX_APER = db.Column(db.Float, nullable=False)
FLUXERR_APER = db.Column(db.Float, nullable=False)
MAG_APER = db.Column(db.Float, nullable=False)
MAGERR_APER = db.Column(db.Float, nullable=False)
FLUX_AUTO = db.Column(db.Float, nullable=False)
FLUXERR_AUTO = db.Column(db.Float, nullable=False)
MAG_AUTO = db.Column(db.Float, nullable=False)
MAGERR_AUTO = db.Column(db.Float, nullable=False)
BACKGROUND = db.Column(db.Float, nullable=False)
THRESHOLD = db.Column(db.Float, nullable=False)
FLUX_MAX = db.Column(db.Float, nullable=False)
XMIN_IMAGE = db.Column(db.Float, nullable=False)
YMIN_IMAGE = db.Column(db.Float, nullable=False)
XMAX_IMAGE = db.Column(db.Float, nullable=False)
YMAX_IMAGE = db.Column(db.Float, nullable=False)
XPEAK_IMAGE = db.Column(db.Float, nullable=False)
YPEAK_IMAGE = db.Column(db.Float, nullable=False)
X_IMAGE = db.Column(db.Float, nullable=False)
Y_IMAGE = db.Column(db.Float, nullable=False)
X2_IMAGE = db.Column(db.Float, nullable=False)
Y2_IMAGE = db.Column(db.Float, nullable=False)
XY_IMAGE = db.Column(db.Float, nullable=False)
CXX_IMAGE = db.Column(db.Float, nullable=False)
CYY_IMAGE = db.Column(db.Float, nullable=False)
CXY_IMAGE = db.Column(db.Float, nullable=False)
A_IMAGE = db.Column(db.Float, nullable=False)
B_IMAGE = db.Column(db.Float, nullable=False)
THETA_IMAGE = db.Column(db.Float, nullable=False)
MU_MAX = db.Column(db.Float, nullable=False)
FLAGS = db.Column(db.Float, nullable=False)
FWHM_IMAGE = db.Column(db.Float, nullable=False)
ELONGATION = db.Column(db.Float, nullable=False)
ELLIPTICITY = db.Column(db.Float, nullable=False)
CLASS_STAR = db.Column(db.Float, nullable=False)
MU_THRESHOLD = db.Column(db.Float, nullable=False)
SNR_WIN = db.Column(db.Float, nullable=False)
DELTAX = db.Column(db.Float, nullable=False)
DELTAY = db.Column(db.Float, nullable=False)
RATIO = db.Column(db.Float, nullable=False)
ROUNDNESS = db.Column(db.Float, nullable=False)
PEAK_CENTROID = db.Column(db.Float, nullable=False)
IS_REAL = db.Column(db.Boolean, nullable=True)
image_id = db.Column(db.Integer, db.ForeignKey('ImagesHOT.id'))
image = db.relationship('ImagesHOT',
backref=db.backref('detected_srcs', order_by=id))
def __repr__(self):
return '{}::{}'.format(self.image, self.NUMBER)
