AssemblyManager

Instance Constructors

new AssemblyManager(m2id: Map[MentionState, IDPointer], id2eer: Map[IDPointer, EER])

Creates a new AssemblyManager from two LUTs: (Mention -> IDPointer) and (IDPointer -> EntityEventRepresentation).
Creates a new AssemblyManager from two LUTs: (Mention -> IDPointer) and (IDPointer -> EntityEventRepresentation). These LUTs are used to populate the mentionStateToID and idToEERepresentation LUTs containing the same information. Subsequent updates to these LUTs create new LUTs. The motivation for the LUTs was to allow for changes in the mapping of a Mention -...-> EntityEventRepresentation to easily propagate in nested cases. For example, an update to the (Mention -> EntityEventRepresentation) mapping of a SimpleEvent Mention will propagate to the (Mention -> EntityEventRepresentation) mapping of any ComplexEvent Mention containing this SimpleEvent Mention.
m2id
a lookup table from Mention -> IDPointer. Each key (Mention) should map to a unique IDPointer.
id2eer
a lookup table from IDPointer -> EntityEventRepresentation. Keys (IDPointer) may point to the same value (EntityEventRepresentation)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def EERdiff(eers1: Set[EER], eers2: Set[EER]): Set[EER]
def EERintersection(eers1: Set[EER], eers2: Set[EER]): Set[EER]
def EERs: Set[EER]

Retrieves all EntityEventRepresentations found in AssemblyManager.idToEER
Retrieves all EntityEventRepresentations found in AssemblyManager.idToEER
returns
the Set of Odin Mentions tracked by this AssemblyManager
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def createComplexWithID(m: Mention): (Complex, IDPointer)

Creates a Complex from a Binding Mention and updates the mentionStateToID and idToEER LUTs
Creates a Complex from a Binding Mention and updates the mentionStateToID and idToEER LUTs
m
an Odin Mention
returns
a tuple of (Complex, IDPointer)

Attributes
protected
def createSimpleEntity(m: Mention, mods: Option[Set[AssemblyModification]]): SimpleEntity

Create a SimpleEntity representation from a Mention and an optional set of optional modifications (useful for building output of SimpleEvent)
Create a SimpleEntity representation from a Mention and an optional set of optional modifications (useful for building output of SimpleEvent)
Whenever modifications are provided, the mentionStateToID LUT is NOT updated, so as to avoid a conflict with the existing mapping (see the description of mods for the motivation)
m
an Odin Mention
mods
an optional set of AssemblyModification. This is useful for building the output of a SimpleEvent (any simple event other than a Binding), which is a set of SimpleEvent where the key PTM comes from the SimpleEvent (i.e., the PTM cannot be recovered by simply examining m out of context)
returns
a SimpleEntity

Attributes
protected
def createSimpleEntityWithID(m: Mention, mods: Option[Set[AssemblyModification]]): (SimpleEntity, IDPointer)

Create a SimpleEntity representation from a Mention and an optional set of optional modifications (useful for building output of SimpleEvent)
Create a SimpleEntity representation from a Mention and an optional set of optional modifications (useful for building output of SimpleEvent)
Whenever modifications are provided, the mentionStateToID LUT is NOT updated, so as to avoid a conflict with the existing mapping (see the description of mods for the motivation)
m
an Odin Mention
mods
an optional set of AssemblyModification. This is useful for building the output of a SimpleEvent (any simple event other than a Binding), which is a set of SimpleEvent where the key PTM comes from the SimpleEvent (i.e., the PTM cannot be recovered by simply examining m out of context)
returns
a tuple of (IDPointer, SimpleEntity)

Attributes
protected
def distinctActivations(polarity: String): Set[Activation]

Returns "distinct" Set of Activations matching the provided polarity.
Returns "distinct" Set of Activations matching the provided polarity. Ignores differences in IDPointers.
polarity
a String to match against each Activation.polarity
returns
a Set of Activations
def distinctActivations: Set[Activation]

Returns "distinct" Set of Activations.
Returns "distinct" Set of Activations. Ignores differences in IDPointers.
returns
a Set of Regulation
def distinctActivationsWithEvidence(polarity: String): Set[(Activation, Set[Mention])]

Returns "distinct" Set of Activations matching the provided polarity and all evidence (Set[Mention]) corresponding to each Activation.
Returns "distinct" Set of Activations matching the provided polarity and all evidence (Set[Mention]) corresponding to each Activation.
polarity
a String to match against each Activation.polarity
returns
Set[(Activation, Set[Mention])]
def distinctActivationsWithEvidence: Set[(Regulation, Set[Mention])]

Returns "distinct" Set of Activations and all evidence (Set[Mention]) corresponding to each Activation.
Returns "distinct" Set of Activations and all evidence (Set[Mention]) corresponding to each Activation.
returns
Set[(Regulation, Set[Mention])]
def distinctComplexes: Set[Complex]

Returns "distinct" Set of Complexes.
Returns "distinct" Set of Complexes. Ignores differences in IDPointers.
returns
a Set of Complexes
def distinctComplexesWithEvidence: Set[(Complex, Set[Mention])]

Returns "distinct" Set of Complexes and all evidence (Set[Mention]) corresponding to each Complex.
Returns "distinct" Set of Complexes and all evidence (Set[Mention]) corresponding to each Complex.
returns
Set[(Complex, Set[Mention])]
def distinctEERs: Set[EER]

Returns head of each group returned by groupedEERs.
Returns head of each group returned by groupedEERs.
returns
a Set of EntityEventRepresentation
def distinctEERsFromSet(eers: Set[EER]): Set[EER]

Gets distinct members of eers after grouping by EntityEventRepresentation.equivalenceHash.
Gets distinct members of eers after grouping by EntityEventRepresentation.equivalenceHash.
eers
an EntityEventRepresentation Set
def distinctEERsWithEvidence: Set[(EER, Set[Mention])]

Returns Set of "distinct" EntityEventRepresentation with corresponding evidence.
def distinctEntities: Set[Entity]

Returns "distinct" Set of Entities.
Returns "distinct" Set of Entities. Ignores multiple instances of the same Entity.
returns
a Set of Entity
def distinctEntitiesWithEvidence: Set[(Entity, Set[Mention])]

Returns "distinct" Set of Entities and all evidence (Set[Mention]) corresponding to each Entity.
Returns "distinct" Set of Entities and all evidence (Set[Mention]) corresponding to each Entity.
returns
Set[(Entity, Set[Mention])]
def distinctEvents: Set[Event]

Returns "distinct" Set of Events.
Returns "distinct" Set of Events. Ignores multiple instances of the same Entity.
returns
a Set of Event
def distinctEventsWithEvidence: Set[(Event, Set[Mention])]

Returns "distinct" Set of Events and all evidence (Set[Mention]) corresponding to each Event.
Returns "distinct" Set of Events and all evidence (Set[Mention]) corresponding to each Event.
returns
Set[(SimpleEntity, Set[Mention])]
def distinctPredecessorsOf(m: Mention): Set[EER]

Retrieves the distinct Set of EER predecessors for the provided Mention (m).
Retrieves the distinct Set of EER predecessors for the provided Mention (m).
m
an Odin Mention
returns
the Set of distinct EntityEventRepresentations known to causally precede the EER corresponding to M
def distinctPredecessorsOf(eer: EER): Set[EER]

Retrieves the distinct Set of EER predecessors for the provided EER.
Retrieves the distinct Set of EER predecessors for the provided EER.
eer
an EntityEventRepresentation
returns
the Set of distinct EntityEventRepresentations known to causally precede any EER corresponding to EntityEventRepresentation.equivalenceHash
def distinctRegulations(polarity: String): Set[Regulation]

Returns "distinct" Set of Regulations matching the provided polarity.
Returns "distinct" Set of Regulations matching the provided polarity. Ignores differences in IDPointers.
polarity
a String to match against each Regulation.polarity
returns
a Set of Regulations
def distinctRegulations: Set[Regulation]

Returns "distinct" Set of Regulation.
Returns "distinct" Set of Regulation. Ignores differences in IDPointers.
returns
a Set of Regulation
def distinctRegulationsWithEvidence(polarity: String): Set[(Regulation, Set[Mention])]

Returns "distinct" Set of Regulations matching the provided polarity and all evidence (Set[Mention]) corresponding to each Regulation.
Returns "distinct" Set of Regulations matching the provided polarity and all evidence (Set[Mention]) corresponding to each Regulation.
polarity
a String to match against each Regulation.polarity
returns
Set[(Regulation, Set[Mention])]
def distinctRegulationsWithEvidence: Set[(Regulation, Set[Mention])]

Returns "distinct" Set of Regulations and all evidence (Set[Mention]) corresponding to each Regulation.
Returns "distinct" Set of Regulations and all evidence (Set[Mention]) corresponding to each Regulation.
returns
Set[(Regulation, Set[Mention])]
def distinctSimpleEntities: Set[SimpleEntity]

Returns "distinct" Set of SimpleEntity.
Returns "distinct" Set of SimpleEntity. Ignores multiple instances of the same SimpleEntity.
returns
a Set of SimpleEntity
def distinctSimpleEntitiesWithEvidence: Set[(SimpleEntity, Set[Mention])]

Returns "distinct" Set of SimpleEntities and all evidence (Set[Mention]) corresponding to each SimpleEntity.
Returns "distinct" Set of SimpleEntities and all evidence (Set[Mention]) corresponding to each SimpleEntity.
returns
Set[(SimpleEntity, Set[Mention])]
def distinctSimpleEvents(label: String): Set[SimpleEvent]

Returns "distinct" Set of SimpleEvents matching the provided event label.
Returns "distinct" Set of SimpleEvents matching the provided event label. Ignores differences in IDPointers.
label
a String to match against each SimpleEvent.label
returns
a Set of SimpleEvents
def distinctSimpleEvents: Set[SimpleEvent]

Returns "distinct" Set of SimpleEvents.
Returns "distinct" Set of SimpleEvents. Ignores differences in IDPointers.
returns
a Set of SimpleEvents
def distinctSimpleEventsWithEvidence(label: String): Set[(SimpleEvent, Set[Mention])]

Returns "distinct" Set of SimpleEvent matching the provided event label and all evidence (Set[Mention]) corresponding to each SimpleEvent.
Returns "distinct" Set of SimpleEvent matching the provided event label and all evidence (Set[Mention]) corresponding to each SimpleEvent.
label
a String to match against each SimpleEvent.label
returns
Set[(SimpleEvent, Set[Mention])]
def distinctSuccessorsOf(m: Mention): Set[EER]

Retrieves the distinct Set of EER successors for the provided Mention (m).
Retrieves the distinct Set of EER successors for the provided Mention (m).
m
an Odin Mention
returns
the Set of distinct EntityEventRepresentations known to causally succeed any EER corresponding to eh
def distinctSuccessorsOf(eer: EER): Set[EER]

Retrieves the distinct Set of EER successors for the provided EER.
Retrieves the distinct Set of EER successors for the provided EER.
eer
an EntityEventRepresentation
returns
the Set of distinct EntityEventRepresentations known to causally succeed any EER corresponding to eh
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def getActivations(polarity: String): Set[Activation]

Retrieves all Activations from the manager matching the provided polarity label.
Retrieves all Activations from the manager matching the provided polarity label. Note that these are non-distinct (Activations may differ in terms of their IDPointers).
polarity
a String to match against each Activation.polarity
def getActivations: Set[Activation]

Retrieves all Activations from the manager.
Retrieves all Activations from the manager. Note that these are non-distinct (Activations may differ in terms of their IDPointers).
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getComplex(m: Mention): Complex

Returns a Regulation for a Mention m with the appropriate label.
Returns a Regulation for a Mention m with the appropriate label.
m
an Odin Mention. Must have the label "Complex".
def getComplexes: Set[Complex]

Retrieves all Complexes from the manager.
Retrieves all Complexes from the manager. Note that these are non-distinct (Complexes may differ in terms of their IDPointers).
def getEER(id: IDPointer): EER

Retrieves an EntityEventRepresentation associated with the given IDPointer.
Retrieves an EntityEventRepresentation associated with the given IDPointer. Assumes an EntityEventRepresentation associated with the provide IDPointer already exists.
id
an IDPointer
returns
an EntityEventRepresentation
def getEER(m: Mention): EER

Retrieves an EntityEventRepresentation for a Mention.
Retrieves an EntityEventRepresentation for a Mention. Assumes an EntityEventRepresentation for the given Mention already exists.
m
an Odin Mention
returns
an EntityEventRepresentation
def getEERs: Set[EER]

Retrieves the Set of EntityEventRepresentation tracked by the manager.
Retrieves the Set of EntityEventRepresentation tracked by the manager.
returns
Set[EntityEventRepresentation]
def getEntities: Set[Entity]

Retrieves all Entities from the manager.
Retrieves all Entities from the manager. Note that these are non-distinct.
def getEntity(m: Mention): Entity

Returns an Entity for a Mention with the appropriate labels.
Returns an Entity for a Mention with the appropriate labels.
m
an Odin Mention. Must have the label "Entity"
def getEquivalentEERs(eer: EER): Set[EER]
def getEquivalentEERs(eh: Int): Set[EER]

Get non-distinct equivalent EERs matching the provided equivalenceHash (eh)
Get non-distinct equivalent EERs matching the provided equivalenceHash (eh)
eh
an EntityEventRepresentation.equivalenceHash
def getEvent(m: Mention): Event

Returns an Event for a Mention with the appropriate labels.
Returns an Event for a Mention with the appropriate labels.
m
an Odin Mention.
def getEvents: Set[Event]

Retrieves all Events from the manager.
Retrieves all Events from the manager. Note that these are non-distinct (Events may differ in terms of their IDPointers).
def getEvidence(eer: EER): Set[Mention]

Collects mentions pointing to a given EntityEventRepresentation.
Collects mentions pointing to a given EntityEventRepresentation.
eer
an EntityEventRepresentation
returns
a sequence of Mention serving as textual evidence of the given representation
def getID(eer: EER): IDPointer

Retrieves ID from an EntityEventRepresentation.uniqueID
Retrieves ID from an EntityEventRepresentation.uniqueID
eer
an EntityEventRepresentation
returns
the IDPointer for the repr
def getMentions: Set[Mention]

Retrieve the set of mentions currently tracked by the manager
def getPolarityLabel(m: Mention): String

Gets the polarity of a mention.
Gets the polarity of a mention. Should only be relevant to ComplexEvents
m
an Odin Mention
returns
AssemblyManager.positive, AssemblyManager.negative, or AssemblyManager.unknown
def getPrecedenceRelations: Set[PrecedenceRelation]

Retrieves the (distinct) Set of PrecedenceRelations for all Events
def getPrecedenceRelationsFor(m: Mention): Set[PrecedenceRelation]

Retrieves the Set of PrecedenceRelations corresponding to the provided Mention
Retrieves the Set of PrecedenceRelations corresponding to the provided Mention
m
an Odin Mention
def getPrecedenceRelationsFor(eer: EER): Set[PrecedenceRelation]

Retrieves the Set of PrecedenceRelations corresponding to the provided EntityEventRepresentation.equivalenceHash (eh)
Retrieves the Set of PrecedenceRelations corresponding to the provided EntityEventRepresentation.equivalenceHash (eh)
eer
an EntityEventRepresentation
def getRegulation(m: Mention): Regulation

Returns a Regulation for a Mention m with the label "Regulation"
Returns a Regulation for a Mention m with the label "Regulation"
m
an Odin Mention. Must have the label "Regulation"
def getRegulations(polarity: String): Set[Regulation]

Retrieves all Regulations from the manager matching the provided polarity label.
Retrieves all Regulations from the manager matching the provided polarity label. Note that these are non-distinct (Regulations may differ in terms of their IDPointers).
polarity
a String to match against each Regulation.polarity
def getRegulations: Set[Regulation]

Retrieves all Regulations from the manager.
Retrieves all Regulations from the manager. Note that these are non-distinct (Regulations may differ in terms of their IDPointers).
def getSimpleEntities: Set[SimpleEntity]

Retrieves all SimpleEntities from the manager.
Retrieves all SimpleEntities from the manager. Note that these are non-distinct.
def getSimpleEntitiesByModification[M <: AssemblyModification](mod: M): Set[SimpleEntity]

Retrieves all SimpleEntities containing the given
Retrieves all SimpleEntities containing the given
mod
an AssemblyModification
returns
a Set of SimpleEntities sharing mod
def getSimpleEntity(m: Mention): SimpleEntity

Returns a SimpleEntity for a Mention with the appropriate labels.
Returns a SimpleEntity for a Mention with the appropriate labels.
m
an Odin Mention. Must have the label "Entity" and not the label "Complex".
def getSimpleEvent(m: Mention): SimpleEvent

Returns a SimpleEvent for a Mention m with the appropriate labels.
Returns a SimpleEvent for a Mention m with the appropriate labels.
m
an Odin Mention. Must have the label "SimpleEvent".
def getSimpleEvents(label: String): Set[SimpleEvent]

Retrieves all SimpleEvents from the manager matching the provided event label.
Retrieves all SimpleEvents from the manager matching the provided event label. Note that these are non-distinct (SimpleEvents may differ in terms of their IDPointers).
label
a String to match against each SimpleEvent.label
def getSimpleEvents: Set[SimpleEvent]

Retrieves all SimpleEvents from the manager.
Retrieves all SimpleEvents from the manager. Note that these are non-distinct (SimpleEvents may differ in terms of their IDPointers).
def groupedEERs: Seq[Set[EER]]

Returns groups of equivalent EntityEventRepresentation, ignoring differences due to IDPointer references.
Returns groups of equivalent EntityEventRepresentation, ignoring differences due to IDPointer references.
Mentions may point to (essentially) the same EntityEventRepresentation, which would only differ in terms of the IDPointer, which link an EntityEventRepresentation to a particular Mention
def hasMention(m: Mention): Boolean
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
def mentionIndexSummary: Seq[String]

A (mostly) human readable printout of the (key, value) pairs in the mentionStateToID] LUT
def mentionSummary(m: Mention): String

A high-level summary of a Mention m
A high-level summary of a Mention m
m
an Odin Mention
returns
a high-level String representation of m
def mkAssemblyModifications(m: Mention): Set[AssemblyModification]

Builds a Set[AssemblyModfication] from the modifcations belonging to a Mention m.
Builds a Set[AssemblyModfication] from the modifcations belonging to a Mention m. Currently, only a subset of Mention org.clulab.reach.mentions.Modification are considered relevant to assembly: PTM Mutant
Additionally, a Mention corresponding to an Entity will include an EntityLabel AssemblyModification encoding its label (ex. Family)
m
an Odin Mention
returns
Set[AssemblyModification]

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def predecessorsOf(m: Mention): Set[EER]

Retrieves the non-distinct Set of EER predecessors for the provided Mention (m).
Retrieves the non-distinct Set of EER predecessors for the provided Mention (m).
m
an Odin Mention
returns
the Set of non-distinct EntityEventRepresentations known to causally precede the EER corresponding to m
def predecessorsOf(eer: EER): Set[EER]

Retrieves the non-distinct Set of EER predecessors for the provided EER.
Retrieves the non-distinct Set of EER predecessors for the provided EER.
eer
an EntityEventRepresentation
returns
the Set of non-distinct EntityEventRepresentations known to causally precede eer
def removeEntriesContainingID(id: IDPointer): Unit

Removes mention and corresponding EntityEventRepresentation associated with the provided id.
Removes mention and corresponding EntityEventRepresentation associated with the provided id. If the corresponding EntityEventRepresentation is a SimpleEvent, remove its output as well.
id
an IDPointer used to identify mentions and EntityEventRepresentations for removal
def removeEntriesContainingIDofEER(eer: EER): Unit

Removes entries referencing the given EntityEventRepresentation.
Removes entries referencing the given EntityEventRepresentation.
eer
an EntityEventRepresentation used to identify mentions and EntityEventRepresentations for removal
def removeEntriesContainingIDofMention(m: Mention): Unit

Removes mention and corresponding EERepresentation from the AssemblyManager
def removeEntriesCorrespondingToIDs(ids: Seq[IDPointer]): Unit

Removes entries referencing the any of the given IDPointer.
Removes entries referencing the any of the given IDPointer.
ids
a Seq[IDPointer] used to identify mentions and EntityEventRepresentations for removal
def saveTo(fileName: String): Unit
def saveTo(f: File): Unit
def storePrecedenceRelation(before: EER, after: EER, foundBy: String, confidence: Double): Unit
def storePrecedenceRelation(before: EER, after: EER, evidence: Set[Mention], foundBy: String, confidence: Double): Unit

Stores a PrecedenceRelation in EERtoPrecedenceRelations for the EERs corresponding to "before" and "after"
Stores a PrecedenceRelation in EERtoPrecedenceRelations for the EERs corresponding to "before" and "after"
before
an EntityEventRepresentation that causally precedes "after"
after
an EntityEventRepresentation that (causally) follows "before"
foundBy
the name of the sieve or procedure that discovered this precedence relation
def storePrecedenceRelation(before: Mention, after: Mention, evidence: Set[Mention] = Set.empty[Mention], foundBy: String, confidence: Double = AssemblyManager.DEFAULT_CONFIDENCE): Unit

Stores a PrecedenceRelation in EERtoPrecedenceRelations connecting "before" and "after".
Stores a PrecedenceRelation in EERtoPrecedenceRelations connecting "before" and "after". Tracks "before" and "after" Mentions and produces EERs, is not already present.
before
an Odin Mention that causally precedes "after"
after
an Odin Mention that (causally) follows "before"
evidence
a Set of Odin Mentions serving as evidence for the precedence relation
foundBy
the name of the sieve or procedure that discovered this precedence relation
def successorsOf(m: Mention): Set[EER]

Retrieves the non-distinct Set of EER successors for the provided Mention (m).
Retrieves the non-distinct Set of EER successors for the provided Mention (m).
m
an Odin Mention
returns
the Set of non-distinct EntityEventRepresentations known to causally succeed the EER corresponding to m
def successorsOf(eer: EER): Set[EER]

Retrieves the non-distinct Set of EER successors for the provided EER.
Retrieves the non-distinct Set of EER successors for the provided EER.
eer
an EntityEventRepresentation
returns
the Set of non-distinct EntityEventRepresentations known to causally succeed eer
def summarizeEntities: Unit
def summarizeMentionIndex: Unit
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trackMention(m: Mention): Unit

Creates an EntityEventRepresentation if m is a valid Mention See isValidMention for details on validation check
Creates an EntityEventRepresentation if m is a valid Mention See isValidMention for details on validation check
m
an Odin Mention
def trackMentions(mentions: Seq[Mention]): Unit

Creates an EntityEventRepresentation for each valid Mention See isValidMention for details on validation check
Creates an EntityEventRepresentation for each valid Mention See isValidMention for details on validation check
mentions
a sequence of Mention to store in the AssemblyManager LUTs
def trackedMentions: Set[Mention]

Retrieves all tracked Mentions from AssemblyManager.mentionStateToID
Retrieves all tracked Mentions from AssemblyManager.mentionStateToID
returns
the Set of Odin Mentions tracked by this AssemblyManager
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object AssemblyManager | package assembly

class AssemblyManager extends Serializable with LazyLogging

Instance Constructors

new AssemblyManager(m2id: Map[MentionState, IDPointer], id2eer: Map[IDPointer, EER])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def EERdiff(eers1: Set[EER], eers2: Set[EER]): Set[EER]

def EERintersection(eers1: Set[EER], eers2: Set[EER]): Set[EER]

def EERs: Set[EER]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def createComplexWithID(m: Mention): (Complex, IDPointer)

def createSimpleEntity(m: Mention, mods: Option[Set[AssemblyModification]]): SimpleEntity

def createSimpleEntityWithID(m: Mention, mods: Option[Set[AssemblyModification]]): (SimpleEntity, IDPointer)

def distinctActivations(polarity: String): Set[Activation]

def distinctActivations: Set[Activation]

def distinctActivationsWithEvidence(polarity: String): Set[(Activation, Set[Mention])]

def distinctActivationsWithEvidence: Set[(Regulation, Set[Mention])]

def distinctComplexes: Set[Complex]

def distinctComplexesWithEvidence: Set[(Complex, Set[Mention])]

def distinctEERs: Set[EER]

def distinctEERsFromSet(eers: Set[EER]): Set[EER]

def distinctEERsWithEvidence: Set[(EER, Set[Mention])]

def distinctEntities: Set[Entity]

def distinctEntitiesWithEvidence: Set[(Entity, Set[Mention])]

def distinctEvents: Set[Event]

def distinctEventsWithEvidence: Set[(Event, Set[Mention])]

def distinctPredecessorsOf(m: Mention): Set[EER]

def distinctPredecessorsOf(eer: EER): Set[EER]

def distinctRegulations(polarity: String): Set[Regulation]

def distinctRegulations: Set[Regulation]

def distinctRegulationsWithEvidence(polarity: String): Set[(Regulation, Set[Mention])]

def distinctRegulationsWithEvidence: Set[(Regulation, Set[Mention])]

def distinctSimpleEntities: Set[SimpleEntity]

def distinctSimpleEntitiesWithEvidence: Set[(SimpleEntity, Set[Mention])]

def distinctSimpleEvents(label: String): Set[SimpleEvent]

def distinctSimpleEvents: Set[SimpleEvent]

def distinctSimpleEventsWithEvidence(label: String): Set[(SimpleEvent, Set[Mention])]

def distinctSuccessorsOf(m: Mention): Set[EER]

def distinctSuccessorsOf(eer: EER): Set[EER]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getActivations(polarity: String): Set[Activation]

def getActivations: Set[Activation]

final def getClass(): Class[_]

def getComplex(m: Mention): Complex

def getComplexes: Set[Complex]

def getEER(id: IDPointer): EER

def getEER(m: Mention): EER

def getEERs: Set[EER]

def getEntities: Set[Entity]

def getEntity(m: Mention): Entity

def getEquivalentEERs(eer: EER): Set[EER]

def getEquivalentEERs(eh: Int): Set[EER]

def getEvent(m: Mention): Event

def getEvents: Set[Event]

def getEvidence(eer: EER): Set[Mention]

def getID(eer: EER): IDPointer

def getMentions: Set[Mention]

def getPolarityLabel(m: Mention): String

def getPrecedenceRelations: Set[PrecedenceRelation]

def getPrecedenceRelationsFor(m: Mention): Set[PrecedenceRelation]

def getPrecedenceRelationsFor(eer: EER): Set[PrecedenceRelation]

def getRegulation(m: Mention): Regulation

def getRegulations(polarity: String): Set[Regulation]

def getRegulations: Set[Regulation]

def getSimpleEntities: Set[SimpleEntity]

def getSimpleEntitiesByModification[M <: AssemblyModification](mod: M): Set[SimpleEntity]

def getSimpleEntity(m: Mention): SimpleEntity

def getSimpleEvent(m: Mention): SimpleEvent

def getSimpleEvents(label: String): Set[SimpleEvent]

def getSimpleEvents: Set[SimpleEvent]

def groupedEERs: Seq[Set[EER]]

def hasMention(m: Mention): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean