private boolean eventToVP(
VerbChunk vc,
Word tg,
Word pr,
Word pr2,
List<Word> prep,
Map<String, Rules> rules[],
int ev_type,
boolean evt1,
boolean evt2,
boolean add) {
boolean prep1_pos, prep2_pos = false, prep_order = false, in_chunk = false;
String prep1 = "", prep2 = "", ctype, pos_type;
int count1 = 0, count2 = 0; // count2 -> for theme2/cause
boolean has_theme2 = false;
String childTrg = "", parentTrg = "";
if (vc.subject.belongTO(tg, pr, pr2)) {
eventToNP(vc.subject, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
} else if (vc.object.belongTO(tg, pr, pr2)) {
eventToNP(vc.object, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
} else if (vc.verb.contains(tg)) { // verb contains trigger
vppt++;
if (curr_event.getLevel(0) >= 2) {
vppt2++;
}
ctype = "VP";
pos_type = tg.pos_tag;
prep1_pos = tg.pos < pr.pos ? true : false;
if (pr2 == null) {
if (vc.subject.containsKey(pr)) {
count1 = vc.subject.getChunkPos(pr.pos);
// or relative clause
prep1 = getPrepFront(tg, pr, vc.subject);
} else if (vc.object.containsKey(pr)) {
count1 = vc.object.getChunkPos(pr.pos);
prep1 = getPrep(tg, pr, vc.object);
}
if (evt1) {
childTrg = pr.word;
}
} else { // Pr2!=null
// for both binding and regulatory events
has_theme2 = true;
prep2_pos = tg.pos < pr2.pos ? true : false;
if (prep1_pos && prep2_pos) { // both are behind trig
count1 = vc.object.getChunkPos(pr.pos);
count2 = vc.object.getChunkPos(pr2.pos);
if (pr.pos < pr2.pos) {
prep1 = getPrep(tg, pr, vc.object);
prep2 = getPrep2(pr, pr2, vc.object);
} else {
prep2 = getPrep(tg, pr2, vc.object);
prep1 = getPrep2(pr2, pr, vc.object);
}
} else if (prep1_pos && !prep2_pos) { // cause - tg - theme
prep1 = getPrep(tg, pr, vc.object);
prep2 = getPrepFront(tg, pr2, vc.subject);
count1 = vc.object.getChunkPos(pr.pos);
count2 = vc.subject.getChunkPos(pr2.pos);
} else if (!prep1_pos && prep2_pos) { // theme - tg - cause
prep1 = getPrepFront(tg, pr, vc.subject);
prep2 = getPrep(tg, pr2, vc.object);
count2 = vc.object.getChunkPos(pr2.pos);
count1 = vc.subject.getChunkPos(pr.pos);
} else if (!prep1_pos && !prep2_pos) { // both are in front of tg
// reg event: few cases, can skip
prep1 = getPrep2(pr, pr2, vc.subject);
prep2 = getPrepFront(tg, pr2, vc.subject);
count1 = vc.subject.getChunkPos(pr.pos);
count2 = vc.subject.getChunkPos(pr2.pos);
if (ev_type > 5) {
return false; // skip this case
}
}
if (ev_type
> 5) { // for binding events: the order of proteins always are PR1-PR2 if they are in
// the same side
if (evt1) {
childTrg = pr.word;
}
if (evt2) {
parentTrg = pr2.word;
}
}
}
Rules rl = rules[ev_type].get(tg.word);
if (rl == null) {
rl = new Rules(ev_type, tg.word);
rules[ev_type].put(tg.word, rl);
}
if (ev_type < 5) {
rl.addPattern(
vc.verb_type, pos_type, ctype, prep1_pos, prep1, in_chunk, count1, childTrg, add);
} else if (ev_type == 5) {
rl.addPattern(
vc.verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
childTrg,
add);
} else {
rl.addPattern(
vc.verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
evt1,
evt2,
childTrg,
parentTrg,
add);
}
} else { // merge subject and subject
BasicChunk new_ch = new BasicChunk();
new_ch.addChunk(vc.subject);
new_ch.addChunk(vc.verb);
new_ch.addChunk(vc.object);
new_ch.is_merged = true;
return eventToNP(new_ch, tg, pr, pr2, prep, rules, ev_type, evt1, evt2, add);
}
return true;
}
private boolean eventToNP(
BasicChunk bs,
Word tg,
Word pr,
Word pr2,
List<Word> prep,
Map<String, Rules> rules[],
int ev_type,
boolean evt1,
boolean evt2,
boolean add) {
boolean prep1_pos, prep2_pos = false, prep_order = false, in_chunk = false;
String prep1 = "", prep2 = "", ctype, pos_type;
int count1, count2 = 0; // for theme2/cause
int verb_type;
boolean has_theme2 = false;
String themeTrg = "", causeTrg = "";
bs.mergeNP();
if (bs.is_merged) {
ctype = "CP";
} else {
ctype = "NP";
}
if (evt1) { // theme
themeTrg = pr.word;
}
if (evt2) { // cause
causeTrg = pr2.word;
}
pos_type = tg.pos_tag;
prep1_pos = pr.pos > tg.pos ? true : false; // prep 1 position
nppt++; // NP pattern
if (pr2 == null) { // only theme
if (bs.isSameChunk(tg, pr) && !evt1) {
Counter ct = sameChunk.get(tg.word);
if (ct == null) {
ct = new Counter(1);
sameChunk.put(tg.word, ct);
} else {
ct.inc();
}
}
count1 = bs.countChunks(tg, pr);
if (prep1_pos) { // TG - PRO
prep1 = getPrep(tg, pr, bs);
if (ev_type <= 5) {
Word sub_tg = findTrg(tg, pr.pos, bs);
if (sub_tg != null) { // found sub-trg
String key = tg.word + tg.pos_tag;
Map<String, Counter> ct = subTG.get(key);
if (ct == null) {
ct = new HashMap<String, Counter>();
subTG.put(key, ct);
}
Counter c = ct.get(sub_tg.word + sub_tg.pos_tag);
if (c == null) {
c = new Counter(1);
ct.put(sub_tg.word + sub_tg.pos_tag, c);
} else {
c.inc();
}
}
}
} else { // PRO - TG
if (!evt1 && bs.inChunk(tg, pr)) {
in_chunk = true;
count1 = 0;
} else if (evt1 && tg.pos == pr.pos) {
in_chunk = true;
count1 = 0;
}
}
if (in_chunk && !evt1) {
Chunk tgc = bs.getChunk(tg.pos);
if (tgc.is_inChunk(tg, tokens) && tgc.trigs.size() == 2) {
// System.out.println("---->"+ tgc.getText()+"\n"+curr_pmid+" "+curr_sen_id);
// bs.printChunk();
// System.out.println("");
}
}
} else {
has_theme2 = true; // has cause/theme2
prep2_pos = pr2.pos > tg.pos ? true : false;
count1 = bs.countChunks(tg, pr);
count2 = bs.countChunks(tg, pr2);
if (prep1_pos && prep2_pos) { // both are behind trig
if (pr.pos > pr2.pos) { // reg only: TG - cause - theme
prep1 = getPrep2(pr2, pr, bs); // theme
prep2 = getPrep(tg, pr2, bs); // cause
prep_order = true; // need to swich order
} else { // binding & reg : TG- theme - cause/theme2
prep2 = getPrep2(pr, pr2, bs); // cause
prep1 = getPrep(tg, pr, bs); // theme
}
} else if (prep1_pos && !prep2_pos) { // cause - tg - theme -> reg only
prep1 = getPrep(tg, pr, bs);
prep2 = getPrepFront(tg, pr2, bs);
} else if (!prep1_pos && prep2_pos) { // theme - tg - cause | theme1 - tg - theme2
prep1 = getPrepFront(tg, pr, bs);
prep2 = getPrep(tg, pr2, bs);
} else { // both are in front of tg
// binding & reg
if (pr.pos > pr2.pos) { // cause/theme2 - theme -TG: should skip this
prep1 = getPrepFront(tg, pr, bs);
prep2 = getPrep2(pr2, pr, bs);
prep_order = true;
} else { // Reg only : theme - cause/theme2 - TG
prep1 = getPrep2(pr, pr2, bs);
prep2 = getPrepFront(tg, pr2, bs);
}
}
if (ev_type == 5) {
in_chunk = bs.inChunk(tg, pr);
// count1 = 0;
} else if (ev_type > 5 && !evt2 && !prep2_pos) { // cause must be pro
in_chunk = bs.inChunk(tg, pr2);
// count2 = 0;
}
} // pr2 condition
verb_type = 0;
Rules rl = rules[ev_type].get(tg.word);
if (rl == null) {
rl = new Rules(ev_type, tg.word);
rules[ev_type].put(tg.word, rl);
}
if (ev_type < 5) {
rl.addPattern(verb_type, pos_type, ctype, prep1_pos, prep1, in_chunk, count1, themeTrg, add);
} else if (ev_type == 5) {
rl.addPattern(
verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
themeTrg,
add);
} else { // regulatory events
rl.addPattern(
verb_type,
pos_type,
ctype,
prep1_pos,
prep2_pos,
prep_order,
prep1,
prep2,
has_theme2,
in_chunk,
count1,
count2,
evt1,
evt2,
themeTrg,
causeTrg,
add);
}
return true;
}
