models.py

                # Only set value of class instance member if
                # value is not None or if field is nullable.
                # Otherwise we could overwrite non-nullable fields
                # which have default values with None.
                if value is not None or f.null:
                    #log.debug("Setting column '%s' with value '%s'" % (f.attname, value))
                    setattr(e, f.attname, value)
            e.save()
            created_events.append(e)

        return created_events

    @classmethod
    def update_event(cls, event, datafile=None):
        """Given an Event (and optional location of coinc.xml) update SingleInspiral data"""
        # XXX Need a better way to find original data.
        if datafile is None:
            datafile = os.path.join(event.datadir(), 'coinc.xml')

        try:
            xmldoc = glue.ligolw.utils.load_filename(datafile, contenthandler=LIGOLWContentHandler)
        except IOError:
            return None

        # Extract Single Inspiral Information
        s_inspiral_tables = glue.ligolw.lsctables.SnglInspiralTable.get_table(xmldoc)

        # Concatentate the tables' rows into a single table
        table = sum(s_inspiral_tables, [])

        event.singleinspiral_set.all().delete()

        return cls.create_events_from_ligolw_table(table, event)

    @classmethod
    def field_names(cls):
        try:
            return cls._field_names
        except AttributeError: pass
        model_field_names = set([ x.name for x in cls._meta.get_fields(include_parents=False) ])
        ligolw_field_names = set(
                glue.ligolw.lsctables.SnglInspiralTable.validcolumns.keys())
        cls._field_names = model_field_names.intersection(ligolw_field_names)
        return cls._field_names

# Event subclass for injections
class SimInspiralEvent(Event):
    mass1                = models.FloatField(null=True)
    mass2                = models.FloatField(null=True)
    eta                  = models.FloatField(null=True)
    amp_order            = models.IntegerField(null=True)
    coa_phase            = models.FloatField(null=True)
    mchirp               = models.FloatField(null=True)
    spin1y               = models.FloatField(null=True)
    spin1x               = models.FloatField(null=True)
    spin1z               = models.FloatField(null=True)
    spin2x               = models.FloatField(null=True)
    spin2y               = models.FloatField(null=True)
    spin2z               = models.FloatField(null=True)
    geocent_end_time     = models.IntegerField(null=True)
    geocent_end_time_ns  = models.IntegerField(null=True)
    end_time_gmst        = models.FloatField(null=True)
    f_lower              = models.FloatField(null=True)
    f_final              = models.FloatField(null=True)
    distance             = models.FloatField(null=True)
    latitude             = models.FloatField(null=True)
    longitude            = models.FloatField(null=True)
    polarization         = models.FloatField(null=True)
    inclination          = models.FloatField(null=True)
    theta0               = models.FloatField(null=True)
    phi0                 = models.FloatField(null=True)
    waveform             = models.CharField(max_length=50, blank=True, default="")
    numrel_mode_min      = models.IntegerField(null=True)
    numrel_mode_max      = models.IntegerField(null=True)
    numrel_data          = models.CharField(max_length=50, blank=True, default="")
    source               = models.CharField(max_length=50, blank=True, default="")
    taper                = models.CharField(max_length=50, blank=True, default="")
    bandpass             = models.IntegerField(null=True)
    alpha                = models.FloatField(null=True)
    beta                 = models.FloatField(null=True)
    psi0                 = models.FloatField(null=True)
    psi3                 = models.FloatField(null=True)
    alpha1               = models.FloatField(null=True)
    alpha2               = models.FloatField(null=True)
    alpha3               = models.FloatField(null=True)
    alpha4               = models.FloatField(null=True)
    alpha5               = models.FloatField(null=True)
    alpha6               = models.FloatField(null=True)
    g_end_time           = models.IntegerField(null=True)
    g_end_time_ns        = models.IntegerField(null=True)
    h_end_time           = models.IntegerField(null=True)
    h_end_time_ns        = models.IntegerField(null=True)
    l_end_time           = models.IntegerField(null=True)
    l_end_time_ns        = models.IntegerField(null=True)
    t_end_time           = models.IntegerField(null=True)
    t_end_time_ns        = models.IntegerField(null=True)
    v_end_time           = models.IntegerField(null=True)
    v_end_time_ns        = models.IntegerField(null=True)
    eff_dist_g           = models.FloatField(null=True)
    eff_dist_h           = models.FloatField(null=True)
    eff_dist_l           = models.FloatField(null=True)
    eff_dist_t           = models.FloatField(null=True)
    eff_dist_v           = models.FloatField(null=True)
    # Additional desired attributes that are not in the SimInspiral table
    source_channel       = models.CharField(max_length=50, blank=True, default="")
    destination_channel  = models.CharField(max_length=50, blank=True, default="")

    @classmethod
    def field_names(cls):
        try:
            return cls._field_names
        except AttributeError: pass
        # We only care about the model field names in this particular case.
        cls._field_names = [ x.name for x in cls._meta.get_fields(include_parents=False) ]
        return cls._field_names

## Tags (user-defined log message attributes)
class Tag(models.Model):
    """Tag Model"""
    # XXX Does the tag need to have a submitter column?
    # No, because creating a tag will generate a log message.
    # For the same reason, a timstamp is not necessary.
    name        = models.CharField(max_length=100)
    displayName = models.CharField(max_length=200,null=True)

    def __unicode__(self):
        if self.displayName:
            return self.displayName
        else:
            return self.name

#     def getEvents(self):
#         # XXX Any way of doing this with filters?
#         # We would need to filter for a non-null intersection of the 
#         # set of log messages in the event with the set of log 
#         # messages in the tag.
#         eventlist = [log.event for log in self.eventlogs.all()]

class VOEvent(models.Model):
    class Meta:
        ordering = ['-created','-N']
        unique_together = ("event","N")
    # Now N will be the serial number.
    event = models.ForeignKey(Event, null=False)
    created = models.DateTimeField(auto_now_add=True)
    issuer = models.ForeignKey(DjangoUser)
    ivorn = models.CharField(max_length=200, default="")
    filename = models.CharField(max_length=100, default="")
    file_version = models.IntegerField(null=True)
    N = models.IntegerField(null=False)
    VOEVENT_TYPE_CHOICES = (('PR','preliminary'), ('IN','initial'), ('UP','update'), ('RE', 'retraction'),)
    voevent_type = models.CharField(max_length=2, choices=VOEVENT_TYPE_CHOICES)

    def fileurl(self):
        if self.filename:
            actual_filename = self.filename
            if self.file_version >= 0:
                actual_filename += ',%d' % self.file_version
            return reverse('file-download', args=[self.event.graceid(),
                actual_filename])
        else:
            return None

    def save(self, *args, **kwargs):
        success = False
        # XXX filename must not be 'None' because null=False for the filename
        # field above.
        self.filename = self.filename or ""
        attempts = 0
        while (not success and attempts < 5):
            attempts = attempts + 1
            if not self.N:
                if self.event.voevent_set.count():
                    self.N = int(self.event.voevent_set.aggregate(models.Max('N'))['N__max']) + 1
                else:
                    self.N = 1
            try:
                super(VOEvent, self).save(*args, **kwargs)
                success = True
            except IntegrityError:
                # IntegrityError means an attempt to insert a duplicate
                # key or to violate a foreignkey constraint.
                # We are under race conditions.  Let's try again.
                pass

        if not success:
            # XXX Should this be a custom exception?  That way we could catch it
            # in the views that use it and give an informative error message.
            raise Exception("Too many attempts to save log message. Something is wrong.")

INSTRUMENTS = ( ('H1', 'LHO'), ('L1', 'LLO'), ('V1', 'Virgo') )
OPERATOR_STATUSES = ( ('OK', 'OKAY'), ('NO', 'NOT OKAY') )
SIGNOFF_TYPE_CHOICES = ( ('OP', 'operator'), ('ADV', 'advocate') )
class Signoff(models.Model):
    class Meta:
        unique_together = ("event","instrument")
    submitter = models.ForeignKey(DjangoUser)
    event = models.ForeignKey(Event)
    signoff_type = models.CharField(max_length=3, choices=SIGNOFF_TYPE_CHOICES, blank=False)
    instrument = models.CharField(max_length=2, choices=INSTRUMENTS, blank=True)
    status = models.CharField(max_length=2, choices=OPERATOR_STATUSES, blank=False)
    comment = models.TextField(blank=True)

    def __unicode__(self):
        return "%s | %s | %s" % (self.event.graceid(), self.instrument, self.status)