class CCD(db.Model):
__tablename__ = 'CCD'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
brand = db.Column(db.String(100), nullable=False)
model = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text, nullable=True)
xpixsize = db.Column(db.Integer, nullable=True)
ypixsize = db.Column(db.Integer, nullable=True)
def __repr__(self):
return self.name
class Classification(db.Model):
__tablename__ = "Classification"
id = db.Column(
db.Integer, db.Sequence('classification_id_seq'), primary_key=True)
name = db.Column(db.String(255), nullable=False, unique=True)
def __repr__(self):
return "<Classification '{}'>".format(self.name)
class SampleModel(db.Model):
__tablename__ = 'SampleModel'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=True, unique=True)
def __eq__(self, obj):
return (isinstance(obj, SampleModel) and obj.name == self.name
and obj.id == self.id)
class Object(db.Model):
"""Model for galaxies observed"""
__tablename__ = "Object"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(12), nullable=False)
def __repr__(self):
return self.name
class MasterCal(db.Model):
__tablename__ = 'MasterCal'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime(timezone=True))
modified_at = db.Column(db.DateTime(timezone=True))
path = db.Column(db.Text, nullable=True)
imagetype = db.Column(db.String(40), nullable=False)
def __repr__(self):
return self.id
class State(db.Model):
__tablename__ = 'State'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
folder = db.Column(db.Text, nullable=True)
order = db.Column(db.Integer, nullable=False)
is_error = db.Column(db.Boolean, nullable=False)
def __repr__(self):
return self.name
class CalFile(db.Model):
__tablename__ = 'CalFile'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.Text, nullable=True)
observation_date = db.Column(db.DateTime(timezone=True))
exptime = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime(timezone=True))
imagetype = db.Column(db.String(16), nullable=False)
def __repr__(self):
return 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 Observatory(db.Model):
"""Model for observatories. SQLAlchemy Model object.
"""
__tablename__ = 'Observatory'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
description = db.Column(db.Text, nullable=True)
def __repr__(self):
return self.name
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 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 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 Tile(db.Model):
"""Represent a VVV tile. Can has 3 states:
- `raw`: The tile is discovery and only a path to the original path
is added
- `measures`: The tile know how many sources they has and the serialized
version of the file is loaded.
- `loaded`: All the sources of the tile are created on *MasterSource* table
"""
__tablename__ = "Tile"
statuses = db.Enum("raw", "measured", "loaded", name="tile_statuses")
ready = db.Column(db.Boolean, default=False)
id = db.Column(db.Integer, db.Sequence('tile_id_seq'), primary_key=True)
name = db.Column(db.String(255), nullable=False, index=True, unique=True)
_filename = db.Column("filename", db.Text)
data = db.Column(db.PickleType, nullable=True)
data_size = db.Column(db.Integer, nullable=True)
data_readed = db.Column(db.Integer, nullable=True)
status = db.Column(statuses, default="raw")
def __repr__(self):
return "<Tile '{}'>".format(self.name)
def file_path(self):
if self._filename:
return os.path.join(
settings.STORED_TILES_DIR, self._filename)
def store_file(self, fpath):
self._filename = os.path.basename(fpath)
shutil.copyfile(fpath, self.file_path())
class Pawprint(db.Model):
__tablename__ = "Pawprint"
statuses = db.Enum("raw", "measured", "loaded", name="pawprint_statuses")
id = db.Column(
db.Integer, db.Sequence('pawprint_id_seq'), primary_key=True)
name = db.Column(db.String(255), nullable=False, unique=True)
mjd = db.Column(db.Float, nullable=True)
data = db.Column(db.PickleType, nullable=True)
data_size = db.Column(db.Integer, nullable=True)
data_readed = db.Column(db.Integer, nullable=True)
_filename = db.Column("filename", db.Text)
status = db.Column(statuses, default="raw")
def __repr__(self):
return "<Pawprint '{}'>".format(repr(self.name))
def file_path(self):
if self._filename:
yearmonth = self._filename[1:7]
day = self._filename[7:9]
return os.path.join(
settings.STORED_PAWPRINT_DIR, yearmonth, day, self._filename)
def store_file(self, fpath):
self._filename = os.path.basename(fpath)
file_path = self.file_path()
file_dir = os.path.dirname(file_path)
if not os.path.isdir(file_dir):
os.makedirs(file_dir)
shutil.copyfile(fpath, file_path)
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 SampleModel(db.Model):
__tablename__ = 'SampleModel'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=True, unique=True)
class Tile(db.Model):
"""Represent a VVV tile. Can has 3 states:
- `raw`: The tile is discovery and only a path to the original path
is added
- `ready`: All the sources of the tile are stored as binary file
The sources are stored in a numpy record array wiht the orinal data
plut the id of every source.
### Understanding the Sources ID:
The id are an 14 digits integer with the format `PTTTOOOOOOOOOO` where:
- **P:** indicate the position of the tile on the VVV (3=bulge, 4=disc).
- **TTT:** Are the tile number of the VVV.
- **OOOOOOOOOO:** is a sequential number of the source inside the tile.
#### Example
The id "40010000000130" (4-001-0000000130) indicate the 130th source
inside the tile d001.
"""
__tablename__ = "Tile"
ZONES = {"b": "3", "d": "4"}
statuses = ("raw", "ready-to-tag", "ready-to-unred", "ready-to-match",
"ready-to-extract-features", "locked")
id = db.Column(db.Integer, db.Sequence('tile_id_seq'), primary_key=True)
name = db.Column(db.String(255), nullable=False, index=True, unique=True)
_raw_filename = db.Column("raw_filename", db.Text)
_npy_filename = db.Column("npy_filename", db.Text)
size = db.Column(db.Integer, nullable=True)
status = db.Column(db.String(255), default="raw")
ogle3_tagged_number = db.Column(db.Integer, nullable=True)
ready = db.Column(db.Boolean, default=False)
def __repr__(self):
return "<Tile '{}'>".format(self.name)
@validates('status')
def _validate_status(self, key, status):
if status not in self.statuses:
raise ValueError("invalid status: " + status)
return status
@property
def vs_number(self):
return self.ogle3_tagged_number
@vs_number.setter
def vs_number(self, n):
self.ogle3_tagged_number = n
@property
def epochs(self):
if not hasattr(self, "_epochs"):
with open(self.raw_file_path) as fp:
epochs = [float(next(fp)) for _ in range(3)]
self._epochs = tuple(epochs)
return self._epochs
@property
def raw_file_path(self):
if self._raw_filename:
return os.path.join(settings.RAW_TILES_DIR, self._raw_filename)
@property
def npy_file_path(self):
if self._npy_filename:
return os.path.join(settings.NPY_TILES_DIR, self._npy_filename)
def store_raw_file(self, fpath):
self._raw_filename = os.path.basename(fpath)
shutil.copyfile(fpath, self.raw_file_path)
def store_npy_file(self, arr):
self._npy_filename = os.path.splitext(self._raw_filename)[0] + ".npy"
np.save(self.npy_file_path, arr)
def load_npy_file(self):
return np.load(self.npy_file_path)
class Alerted(db.Model):
__tablename__ = '__corral_alerted__'
id = db.Column(db.Integer, primary_key=True)
alert_path = db.Column(db.String(1000))
model_table = db.Column(db.String(1000))
model_ids = db.Column(db.PickleType)
created_at = db.Column(db.DateTime(timezone=True))
@classmethod
def model_class_to_column(cls, mcls):
table = mcls.__table__
return {"model_table": table.name}
@classmethod
def model_to_columns(cls, m):
table = m.__table__
instance_as_dict = m._sa_instance_state.dict
ids = {
c: instance_as_dict[c]
for c in table.primary_key.columns.keys()
}
columns = cls.model_class_to_column(type(m))
columns.update({"model_ids": ids})
return columns
@classmethod
def alert_to_columns(cls, alert_cls):
return {
"alert_path": ".".join([alert_cls.__module__, alert_cls.__name__])
}
@classmethod
def all_models(cls):
if not hasattr(Alerted, "_all_models"):
Alerted._all_models = {
cls.__tablename__: cls
for cls in util.collect_subclasses(db.Model)
}
return Alerted._all_models
@property
def model(self):
if not hasattr(self, "_m"):
session = object_session(self)
Model = self.all_models()[self.model_table]
filters = self.model_ids
self._m = session.query(Model).filter_by(**filters).first()
return self._m
@model.setter
def model(self, m):
columns = self.model_to_columns(m)
self.model_table = columns["model_table"]
self.model_ids = columns["model_ids"]
@property
def alert(self):
return util.dimport(self.alert_path)
@alert.setter
def alert(self, a):
columns = self.alert_to_columns(a)
self.alert_path = columns["alert_path"]
class Name(db.Model):
__tablename__ = 'Name'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)