forked from D-Net/dnet-hadoop
135 lines
3.6 KiB
Java
135 lines
3.6 KiB
Java
package eu.dnetlib.pace.tree.support;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
public class TreeNodeStats implements Serializable {
|
|
|
|
private Map<String, FieldStats> results; //this is an accumulator for the results of the node
|
|
|
|
public TreeNodeStats(){
|
|
this.results = new HashMap<>();
|
|
}
|
|
|
|
public Map<String, FieldStats> getResults() {
|
|
return results;
|
|
}
|
|
|
|
public void addFieldStats(String id, FieldStats fieldStats){
|
|
this.results.put(id, fieldStats);
|
|
}
|
|
|
|
public int fieldsCount(){
|
|
return this.results.size();
|
|
}
|
|
|
|
public int undefinedCount(){
|
|
int undefinedCount = 0;
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult() == -1)
|
|
undefinedCount ++;
|
|
}
|
|
return undefinedCount;
|
|
}
|
|
|
|
public double scoreSum(){
|
|
double scoreSum = 0.0;
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult()>=0.0) {
|
|
scoreSum += fs.getResult();
|
|
}
|
|
}
|
|
return scoreSum;
|
|
}
|
|
|
|
//return the sum of the weights without considering the fields with countIfMissing=false && result=-1
|
|
public double weightSum(){
|
|
double weightSum = 0.0;
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult()>=0.0 || (fs.getResult()<0.0 && fs.isCountIfUndefined())) {
|
|
weightSum += fs.getWeight();
|
|
}
|
|
}
|
|
return weightSum;
|
|
}
|
|
|
|
public double weightedScoreSum(){
|
|
double weightedScoreSum = 0.0;
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult()>=0.0) {
|
|
weightedScoreSum += fs.getResult()*fs.getWeight();
|
|
}
|
|
}
|
|
return weightedScoreSum;
|
|
}
|
|
|
|
public double max(){
|
|
double max = -1.0;
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult()>max)
|
|
max = fs.getResult();
|
|
}
|
|
return max;
|
|
}
|
|
|
|
public double min(){
|
|
double min = 100.0; //random high value
|
|
for(FieldStats fs: this.results.values()){
|
|
if(fs.getResult()<min) {
|
|
if (fs.getResult()>=0.0 || (fs.getResult() == -1 && fs.isCountIfUndefined()))
|
|
min = fs.getResult();
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
|
|
//if at least one is true, return 1.0
|
|
public double or(){
|
|
for (FieldStats fieldStats : this.results.values()) {
|
|
if (fieldStats.getResult() >= fieldStats.getThreshold())
|
|
return 1.0;
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
//if at least one is false, return 0.0
|
|
public double and() {
|
|
for (FieldStats fieldStats : this.results.values()) {
|
|
|
|
if (fieldStats.getResult() == -1) {
|
|
if (fieldStats.isCountIfUndefined())
|
|
return 0.0;
|
|
}
|
|
else {
|
|
if (fieldStats.getResult() < fieldStats.getThreshold())
|
|
return 0.0;
|
|
}
|
|
|
|
}
|
|
return 1.0;
|
|
}
|
|
|
|
public double getFinalScore(AggType aggregation){
|
|
|
|
switch (aggregation){
|
|
case AVG:
|
|
return scoreSum()/fieldsCount();
|
|
case SUM:
|
|
return scoreSum();
|
|
case MAX:
|
|
return max();
|
|
case MIN:
|
|
return min();
|
|
case W_MEAN:
|
|
return weightedScoreSum()/weightSum();
|
|
case OR:
|
|
return or();
|
|
case AND:
|
|
return and();
|
|
default:
|
|
return 0.0;
|
|
}
|
|
}
|
|
}
|