private BasicDBList processGeneList(String genes) {
BasicDBList list = new BasicDBList();
Client wsRestClient = Client.create();
WebResource webResource =
wsRestClient.resource("http://ws.bioinfo.cipf.es/cellbase/rest/latest/hsa/feature/gene/");
ObjectMapper mapper = new ObjectMapper();
String response =
webResource.path(genes).path("info").queryParam("of", "json").get(String.class);
try {
JsonNode actualObj = mapper.readTree(response);
Iterator<JsonNode> it = actualObj.iterator();
Iterator<JsonNode> aux;
while (it.hasNext()) {
JsonNode node = it.next();
if (node.isArray()) {
aux = node.iterator();
while (aux.hasNext()) {
JsonNode auxNode = aux.next();
DBObject regionClause = new BasicDBObject("chr", auxNode.get("chromosome").asText());
regionClause.put(
"pos",
new BasicDBObject("$gte", auxNode.get("start").asInt())
.append("$lte", auxNode.get("end").asInt()));
list.add(regionClause);
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
public QueryResult<VariantAnalysisInfo> getAnalysisInfo(String studyId) {
long start = System.currentTimeMillis();
QueryResult<VariantAnalysisInfo> qres = new QueryResult<>();
VariantAnalysisInfo vi = new VariantAnalysisInfo();
DBCollection coll = db.getCollection("sources");
DBCollection collV = db.getCollection("variants");
long dbStart = System.currentTimeMillis();
DBObject study = coll.findOne(new BasicDBObject("alias", studyId));
if (study != null) {
Iterator<Object> it = ((BasicDBList) study.get("samples")).iterator();
while (it.hasNext()) {
vi.addSample((String) it.next());
}
BasicDBObject gs = (BasicDBObject) study.get("globalStats");
for (String elem : gs.keySet()) {
if (!elem.equalsIgnoreCase("consequenceTypes")) {
double val = gs.getDouble(elem);
vi.addGlobalStats(elem, val);
} else {
BasicDBObject cts = (BasicDBObject) gs.get("consequenceTypes");
for (String ct : cts.keySet()) {
vi.addConsequenceType(ct, cts.getInt(ct));
}
}
}
}
qres.setDbTime(System.currentTimeMillis() - dbStart);
qres.setResult(Arrays.asList(vi));
qres.setTime(System.currentTimeMillis() - start);
return qres;
}
private static DBObject normalize(DBObject obj) {
BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();
Iterator<String> iterator = obj.keySet().iterator();
builder.push("$set");
while (iterator.hasNext()) {
String key = iterator.next();
if (Constants.ID_PROPERTY.equals(key)) continue;
Object value = obj.get(key);
if (value == null) continue;
builder.add(key, value);
}
return builder.get();
}
// --------------------------------------------------------------------------------
private void drawItem(String parentFieldName, TreeItem parentItem, Map data, boolean expand) {
Iterator p = data.keySet().iterator();
while (p.hasNext()) {
String key = (String) p.next();
if (!data.containsKey(key)) {
continue;
}
Object value = data.get(key);
TreeItem newItem = new TreeItem(parentItem, SWT.NONE);
newItem.setText(1, getClassName(value));
String fieldName = parentFieldName + "." + key;
if (fieldName.startsWith(".")) {
fieldName = fieldName.substring(1);
}
newItem.setData("fieldName", fieldName);
newItem.setData("value", value);
fieldNameTreeItemMap.put(fieldName, newItem);
if (value == null) {
newItem.setText(key + " : null");
newItem.setImage(nullImage);
} else if (value instanceof Map) {
newItem.setText(key);
newItem.setImage(mapImage);
drawItem(fieldName, newItem, (Map) value, expand);
} else if (value instanceof List) {
newItem.setText(key);
newItem.setImage(listImage);
drawItem(fieldName, newItem, (List) value, expand);
} else {
setItemInfo(newItem, key, value);
}
if (expand) {
parentItem.setExpanded(expand);
newItem.setExpanded(expand);
}
}
}
public TaskWrite(Map map1, Map m_max, Map m_min, DBCollection coll, ModbusSlaveSet slave) {
try {
synchronized (slave) {
Calendar calener = Calendar.getInstance();
Date d1 = calener.getTime();
Date d2 = new Date(calener.getTime().getTime() - 5000);
BasicDBObject b2 = new BasicDBObject();
b2.put("$gte", d2);
b2.put("$lte", d1);
DBCursor cursor =
coll.find(new BasicDBObject("_id", b2)).sort(new BasicDBObject("_id", -1)).limit(1);
while (cursor.hasNext()) {
DBObject dbo = cursor.next();
Set set1 = map1.entrySet();
Iterator it1 = set1.iterator();
while (it1.hasNext()) {
Map.Entry<String, Map<String, String>> entry =
(Map.Entry<String, Map<String, String>>) it1.next();
Map<String, String> map2 = entry.getValue();
for (Iterator it2 = map2.entrySet().iterator(); it2.hasNext(); ) {
Map.Entry<String, String> entry2 = (Map.Entry<String, String>) it2.next();
String name = entry2.getKey().toString();
String paramAddr = entry2.getValue().toString();
int fun = (int) (Double.parseDouble(paramAddr));
if (paramAddr.substring(0, 1).equals("4")) {
double value = Double.parseDouble(dbo.get(name).toString());
double dmax = (Double) m_max.get(name);
double dmin = (Double) m_min.get(name);
double dValue = 0;
if (value > dmax || value < dmin) {
if (value >= 0) {
dValue = 32000 * (int) (value / dmax);
}
if (value < 0) {
dValue = -32000 * (int) (value / dmin);
}
// slave.getProcessImage(3).setInputRegister(fun % 10000, (short) dValue);
} else { /// 参数超限报警
JOptionPane.showMessageDialog(null, "参数超限");
slave.stop();
}
}
if (paramAddr.substring(0, 1).equals("3")) {
double value = Double.parseDouble(dbo.get(name).toString());
double dmax = (Double) m_max.get(name);
double dmin = (Double) m_min.get(name);
double dValue = 0;
if (value > dmax || value < dmin) {
if (value >= 0) {
dValue = 32000 * (int) (value / dmax);
}
if (value < 0) {
dValue = -32000 * (int) (value / dmin);
}
// slave.getProcessImage(3).setHoldingRegister(fun % 10000, (short) dValue);
} else { /// 参数超限报警
JOptionPane.showMessageDialog(null, "参数超限");
slave.stop();
}
;
}
if (paramAddr.substring(0, 1).equals("2")) {
String value = dbo.get(name).toString();
/// slave.getProcessImage(4).setInput(fun % 10000, Boolean.valueOf(value));
}
if (paramAddr.substring(0, 1).equals("1")) {
String value = dbo.get(name).toString();
// slave.getProcessImage(4).setCoil(fun % 10000, Boolean.valueOf(value));
}
}
}
}
}
} catch (Exception ex) {
}
}
public TaskRead(Map map1, Map m_max, Map m_min, DBCollection coll, ModbusSlaveSet slave) {
try {
//// 此处只要点击开始就能保存数据
/// 方案：利用数据源发送单个布尔型变量（1,0）交替，链接成功，先判断是否链接成功，然后在保存数据
synchronized (slave) {
Map map = new HashMap();
Set set1 = map1.entrySet();
Iterator it1 = set1.iterator();
while (it1.hasNext()) {
Map.Entry<String, Map<String, String>> entry =
(Map.Entry<String, Map<String, String>>) it1.next();
Map<String, String> map2 = entry.getValue();
for (Iterator it2 = map2.entrySet().iterator(); it2.hasNext(); ) {
Map.Entry<String, String> entry2 = (Map.Entry<String, String>) it2.next();
String name = entry2.getKey().toString();
String paramAddr = entry2.getValue().toString();
int fun = (int) (Double.parseDouble(paramAddr));
if (paramAddr.substring(0, 1).equals("4")) {
Short d4 = slave.getProcessImage(1).getInputRegister(fun % 10000);
double dmax = (Double) m_max.get(name);
double dmin = (Double) m_min.get(name);
double dValue = 0;
if (d4 >= 0) {
dValue = dmax * d4 / 32000;
} else {
dValue = dmin * d4 / (-32000);
}
map.put(name, dValue);
}
if (paramAddr.substring(0, 1).equals("3")) {
Short d3 = slave.getProcessImage(1).getHoldingRegister(fun % 10000);
double dmax = (Double) m_max.get(name);
double dmin = (Double) m_min.get(name);
double dValue = 0;
if (d3 >= 0) {
dValue = dmax * d3 / 32000;
} else {
dValue = dmin * d3 / (-32000);
}
map.put(name, dValue);
}
if (paramAddr.substring(0, 1).equals("2")) {
map.put(name, slave.getProcessImage(2).getInput(fun % 10000));
}
if (paramAddr.substring(0, 1).equals("1")) {
Boolean a = slave.getProcessImage(2).getCoil(fun % 10000 - 1);
map.put(name, a);
}
}
}
Calendar calendar = Calendar.getInstance();
Date dd = calendar.getTime();
BasicDBObject doc = new BasicDBObject();
doc.put("_id", dd);
Set set = map.entrySet();
Iterator it = set.iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry1 = (Map.Entry<String, String>) it.next();
doc.put(entry1.getKey(), entry1.getValue());
}
coll.insert(doc);
}
} catch (Exception ex) {
}
}
public QueryResult<VariantInfo> getRecordsMongo(
int page, int start, int limit, MutableInt count, Map<String, String> options) {
long startTime = System.currentTimeMillis();
QueryResult<VariantInfo> queryResult = new QueryResult<>();
List<VariantInfo> res = new ArrayList<>();
String sourceId = options.get("studyId");
DBCollection coll = db.getCollection("variants");
BasicDBObject elemMatch = new BasicDBObject("sourceId", sourceId);
DBObject query = new BasicDBObject();
BasicDBList orList = new BasicDBList();
Map<String, List<String>> sampleGenotypes = processSamplesGT(options);
System.out.println("map = " + options);
if (options.containsKey("region") && !options.get("region").equals("")) {
String[] regions = options.get("region").split(",");
Pattern pattern = Pattern.compile("(\\w+):(\\d+)-(\\d+)");
Matcher matcher, matcherChr;
for (int i = 0; i < regions.length; i++) {
String region = regions[i];
matcher = pattern.matcher(region);
if (matcher.find()) {
String chr = matcher.group(1);
int s = Integer.valueOf(matcher.group(2));
int e = Integer.valueOf(matcher.group(3));
DBObject regionClause = new BasicDBObject("chr", chr);
regionClause.put("pos", new BasicDBObject("$gte", s).append("$lte", e));
orList.add(regionClause);
} else {
Pattern patternChr = Pattern.compile("(\\w+)");
matcherChr = patternChr.matcher(region);
if (matcherChr.find()) {
String chr = matcherChr.group();
DBObject regionClause = new BasicDBObject("chr", chr);
orList.add(regionClause);
}
}
}
query.put("$or", orList);
} else if (options.containsKey("genes") && !options.get("genes").equals("")) {
orList = processGeneList(options.get("genes"));
if (orList.size() > 0) {
query.put("$or", orList);
} else {
queryResult.setWarningMsg("Wrong gene name");
queryResult.setResult(res);
queryResult.setNumResults(res.size());
return queryResult;
}
}
if (options.containsKey("conseq_type") && !options.get("conseq_type").equals("")) {
String[] cts = options.get("conseq_type").split(",");
BasicDBList ctList = new BasicDBList();
for (String ct : cts) {
ctList.add(ct);
}
elemMatch.put("effects", new BasicDBObject("$in", ctList));
}
if (sampleGenotypes.size() > 0) {
for (Map.Entry<String, List<String>> entry : sampleGenotypes.entrySet()) {
BasicDBList gtList = new BasicDBList();
for (String gt : entry.getValue()) {
gtList.add(gt);
}
elemMatch.put("samples." + entry.getKey() + ".GT", new BasicDBObject("$in", gtList));
}
}
if (options.containsKey("miss_gt") && !options.get("miss_gt").equalsIgnoreCase("")) {
Integer val = Integer.valueOf(options.get("miss_gt"));
Object missGt = getMongoOption(options.get("option_miss_gt"), val);
elemMatch.put("stats.missGenotypes", missGt);
}
BasicDBList andControls = new BasicDBList();
if (options.containsKey("maf_1000g_controls")
&& !options.get("maf_1000g_controls").equalsIgnoreCase("")) {
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.1000G_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.1000G_maf",
new BasicDBObject("$lte", options.get("maf_1000g_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_1000g_afr_controls")
&& !options.get("maf_1000g_afr_controls").equalsIgnoreCase("")) {
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.1000G_AFR_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.1000G_AFR_maf",
new BasicDBObject("$lte", options.get("maf_1000g_afr_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_1000g_asi_controls")
&& !options.get("maf_1000g_asi_controls").equalsIgnoreCase("")) {
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.1000G_ASI_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.1000G_ASI_maf",
new BasicDBObject("$lte", options.get("maf_1000g_asi_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_1000g_eur_controls")
&& !options.get("maf_1000g_eur_controls").equalsIgnoreCase("")) {
System.out.print("EUR");
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.1000G_EUR_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.1000G_EUR_maf",
new BasicDBObject("$lte", options.get("maf_1000g_eur_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_1000g_ame_controls")
&& !options.get("maf_1000g_ame_controls").equalsIgnoreCase("")) {
System.out.print("AME");
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.1000G_AME_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.1000G_AME_maf",
new BasicDBObject("$lte", options.get("maf_1000g_ame_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_evs_controls")
&& !options.get("maf_evs_controls").equalsIgnoreCase("")) {
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.EVS_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.EVS_maf", new BasicDBObject("$lte", options.get("maf_evs_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (options.containsKey("maf_bier_controls")
&& !options.get("maf_bier_controls").equalsIgnoreCase("")) {
BasicDBList or = new BasicDBList();
or.add(new BasicDBObject("attributes.BIER_maf", new BasicDBObject("$exists", false)));
or.add(
new BasicDBObject(
"attributes.BIER_maf", new BasicDBObject("$lte", options.get("maf_bier_controls"))));
andControls.add(new BasicDBObject("$or", or));
}
if (andControls.size() > 0) {
elemMatch.append("$and", andControls);
}
query.put("sources", new BasicDBObject("$elemMatch", elemMatch));
System.out.println("#############################");
System.out.println(query);
System.out.println("#############################");
long dbStart = System.currentTimeMillis();
DBObject sort = null;
DBCursor cursor;
if (options.containsKey("sort")) {
sort = getQuerySort(options.get("sort"));
cursor = coll.find(query).sort(sort).skip(start).limit(limit);
} else {
cursor = coll.find(query).skip(start).limit(limit);
}
count.setValue(cursor.count());
queryResult.setDbTime(dbStart - System.currentTimeMillis());
for (DBObject obj : cursor) {
BasicDBObject elem = (BasicDBObject) obj;
VariantInfo vi = new VariantInfo();
VariantStats vs = new VariantStats();
String chr = elem.getString("chr");
int pos = elem.getInt("pos");
vi.setChromosome(chr);
vi.setPosition(pos);
BasicDBList studies = (BasicDBList) elem.get("sources");
Iterator<Object> it = studies.iterator();
while (it.hasNext()) {
BasicDBObject study = (BasicDBObject) it.next();
if (study.getString("sourceId").equalsIgnoreCase(sourceId)) {
BasicDBObject stats = (BasicDBObject) study.get("stats");
String ref = study.getString("ref");
BasicDBList alt = (BasicDBList) study.get("alt");
vi.setRef(ref);
vi.setAlt(Joiner.on(",").join(alt.toArray()));
vs.setMaf((float) stats.getDouble("maf"));
vs.setMgf((float) stats.getDouble("mgf"));
vs.setMafAllele(stats.getString("alleleMaf"));
vs.setMgfAllele(stats.getString("genotypeMaf"));
vs.setMissingAlleles(stats.getInt("missAllele"));
vs.setMissingGenotypes(stats.getInt("missGenotypes"));
vs.setMendelinanErrors(stats.getInt("mendelErr"));
vs.setCasesPercentDominant((float) stats.getDouble("casesPercentDominant"));
vs.setControlsPercentDominant((float) stats.getDouble("controlsPercentDominant"));
vs.setCasesPercentRecessive((float) stats.getDouble("casesPercentRecessive"));
vs.setControlsPercentRecessive((float) stats.getDouble("controlsPercentRecessive"));
BasicDBObject samples = (BasicDBObject) study.get("samples");
for (String sampleName : samples.keySet()) {
DBObject sample = (DBObject) samples.get(sampleName);
if (sample.containsField("GT")) {
String sampleGT = (String) sample.get("GT");
vi.addSammpleGenotype(sampleName, sampleGT);
}
}
vi.setSnpid((String) study.get("snpId"));
if (study.containsField("effects")) {
BasicDBList conseqTypes = (BasicDBList) study.get("effects");
conseqTypes.remove("");
String cts = Joiner.on(",").join(conseqTypes.iterator());
vi.addConsequenceTypes(cts);
}
if (study.containsField("genes")) {
BasicDBList genesList = (BasicDBList) study.get("genes");
String genes = Joiner.on(",").join(genesList.iterator());
vi.addGenes(genes);
}
if (study.containsField("attributes")) {
BasicDBObject attr = (BasicDBObject) study.get("attributes");
if (attr.containsField("1000G_maf")) {
vi.addControl("1000G_maf", (String) attr.get("1000G_maf"));
vi.addControl("1000G_amaf", (String) attr.get("1000G_amaf"));
vi.addControl("1000G_gt", (String) attr.get("1000G_gt"));
}
if (attr.containsField("1000G_ASI_maf")) {
vi.addControl("1000G-ASI_maf", (String) attr.get("1000G_ASI_maf"));
vi.addControl("1000G-ASI_amaf", (String) attr.get("1000G_ASI_amaf"));
vi.addControl("1000G-ASI_gt", (String) attr.get("1000G_ASI_gt"));
}
if (attr.containsField("1000G_AFR_maf")) {
vi.addControl("1000G-AFR_maf", (String) attr.get("1000G_AFR_maf"));
vi.addControl("1000G-AFR_amaf", (String) attr.get("1000G_AFR_amaf"));
vi.addControl("1000G-AFR_gt", (String) attr.get("1000G_AFR_gt"));
}
if (attr.containsField("1000G_AME_maf")) {
vi.addControl("1000G-AME_maf", (String) attr.get("1000G_AME_maf"));
vi.addControl("1000G-AME_amaf", (String) attr.get("1000G_AME_amaf"));
vi.addControl("1000G-AME_gt", (String) attr.get("1000G_AME_gt"));
}
if (attr.containsField("1000G_EUR_maf")) {
vi.addControl("1000G-EUR_maf", (String) attr.get("1000G_EUR_maf"));
vi.addControl("1000G-EUR_amaf", (String) attr.get("1000G_EUR_amaf"));
vi.addControl("1000G-EUR_gt", (String) attr.get("1000G_EUR_gt"));
}
if (attr.containsField("EVS_maf")) {
vi.addControl("EVS_maf", (String) attr.get("EVS_maf"));
vi.addControl("EVS_amaf", (String) attr.get("EVS_amaf"));
vi.addControl("EVS_gt", (String) attr.get("EVS_gt"));
}
if (attr.containsField("BIER_maf")) {
vi.addControl("BIER_maf", (String) attr.get("BIER_maf"));
vi.addControl("BIER_amaf", (String) attr.get("BIER_amaf"));
vi.addControl("BIER_gt", (String) attr.get("BIER_gt"));
}
if (attr.containsField("PolyphenScore")) {
vi.setPolyphen_score(Double.parseDouble(attr.getString("PolyphenScore")));
vi.setPolyphen_effect(Integer.parseInt(attr.getString("PolyphenEffect")));
}
if (attr.containsField("SIFTScore")) {
vi.setSift_score(Double.parseDouble(attr.getString("SIFTScore")));
vi.setSift_effect(Integer.parseInt(attr.getString("SIFTEffect")));
}
}
continue;
}
}
vi.addStats(vs);
res.add(vi);
}
queryResult.setResult(res);
queryResult.setTime(startTime - System.currentTimeMillis());
return queryResult;
}
public List<Variant> getRecordSimpleStats(
String study, int missing_gt, float maf, String maf_allele) {
BasicDBObject compare =
new BasicDBObject("studies.stats.allele_maf", maf_allele)
.append("studies.stats.MAF", maf)
.append("studies.stats.missing", missing_gt);
List<Get> hbaseQuery = new ArrayList<>();
DBCollection collection = db.getCollection("variants");
Iterator<DBObject> result = collection.find(compare);
String chromosome = new String();
while (result.hasNext()) {
DBObject variant = result.next();
String position = variant.get("_id").toString();
// hbase query construction
Get get = new Get(position.getBytes());
hbaseQuery.add(get);
}
// Complete results, from HBase
tableName = study;
effectTableName = tableName + "effect";
Map<String, Variant> resultsMap = new HashMap<>();
try {
HTable table = new HTable(admin.getConfiguration(), tableName);
HTable effectTable = new HTable(admin.getConfiguration(), effectTableName);
Result[] hbaseResultEffect = effectTable.get(hbaseQuery);
Result[] hbaseResultStats = table.get(hbaseQuery);
// List<Variant> results = new LinkedList<>();
for (Result r : hbaseResultStats) {
String position = new String(r.getRow(), CHARSET_UTF_8);
String[] aux = position.split("_");
String inner_position = aux[1];
String chr = aux[0];
// position parsing
if (chr.startsWith("0")) {
chr = chr.substring(1);
}
while (inner_position.startsWith("0")) {
inner_position = inner_position.substring(1);
}
List<VariantFieldsProtos.VariantSample> samples = new LinkedList<>();
NavigableMap<byte[], byte[]> infoMap = r.getFamilyMap("i".getBytes());
byte[] byteStats = infoMap.get((study + "_stats").getBytes());
VariantFieldsProtos.VariantStats stats =
VariantFieldsProtos.VariantStats.parseFrom(byteStats);
byte[] byteInfo = infoMap.get((study + "_data").getBytes());
VariantFieldsProtos.VariantInfo info = VariantFieldsProtos.VariantInfo.parseFrom(byteInfo);
String alternate = StringUtils.join(info.getAlternateList(), ", ");
String reference = info.getReference();
Variant partialResult =
new Variant(
chr,
Integer.parseInt(inner_position),
Integer.parseInt(inner_position),
reference,
alternate);
String format = StringUtils.join(info.getFormatList(), ":");
NavigableMap<byte[], byte[]> sampleMap = r.getFamilyMap("d".getBytes());
Map<String, Map<String, String>> resultSampleMap = new HashMap<>();
// StringBuilder sampleRaw = new StringBuilder();
for (byte[] s : sampleMap.keySet()) {
String qual = (new String(s, CHARSET_UTF_8)).replaceAll(study + "_", "");
VariantFieldsProtos.VariantSample sample =
VariantFieldsProtos.VariantSample.parseFrom(sampleMap.get(s));
String sample1 = sample.getSample();
String[] values = sample1.split(":");
String[] fields = format.split(":");
Map<String, String> singleSampleMap = new HashMap<>();
for (int i = 0; i < fields.length; i++) {
singleSampleMap.put(fields[i], values[i]);
}
resultSampleMap.put(qual, singleSampleMap);
}
VariantStats variantStats =
new VariantStats(
chromosome,
Integer.parseInt(inner_position),
reference,
alternate,
stats.getMaf(),
stats.getMgf(),
stats.getMafAllele(),
stats.getMgfGenotype(),
stats.getMissingAlleles(),
stats.getMissingGenotypes(),
stats.getMendelianErrors(),
stats.getIsIndel(),
stats.getCasesPercentDominant(),
stats.getControlsPercentDominant(),
stats.getCasesPercentRecessive(),
stats.getControlsPercentRecessive());
partialResult.setStats(variantStats);
resultsMap.put(new String(r.getRow(), CHARSET_UTF_8), partialResult);
}
for (Result r : hbaseResultEffect) {
if (!r.isEmpty()) {
NavigableMap<byte[], byte[]> effectMap = r.getFamilyMap("e".getBytes());
Variant partialResult = resultsMap.get(new String(r.getRow(), CHARSET_UTF_8));
System.out.println("Recuperado " + partialResult.toString());
String s = partialResult.getReference() + "_" + partialResult.getAlternate();
VariantEffectProtos.EffectInfo effectInfo =
VariantEffectProtos.EffectInfo.parseFrom(effectMap.get(s.getBytes()));
VariantEffect variantEffect =
new VariantEffect(
partialResult.getChromosome(),
(int) partialResult.getStart(),
partialResult.getReference(),
partialResult.getAlternate(),
effectInfo.getFeatureId(),
effectInfo.getFeatureName(),
effectInfo.getFeatureType(),
effectInfo.getFeatureBiotype(),
effectInfo.getFeatureChromosome(),
effectInfo.getFeatureStart(),
effectInfo.getFeatureEnd(),
effectInfo.getFeatureStrand(),
effectInfo.getSnpId(),
effectInfo.getAncestral(),
effectInfo.getAlternative(),
effectInfo.getGeneId(),
effectInfo.getTranscriptId(),
effectInfo.getGeneName(),
effectInfo.getConsequenceType(),
effectInfo.getConsequenceTypeObo(),
effectInfo.getConsequenceTypeDesc(),
effectInfo.getConsequenceTypeType(),
effectInfo.getAaPosition(),
effectInfo.getAminoacidChange(),
effectInfo.getCodonChange());
resultsMap.put(new String(r.getRow(), CHARSET_UTF_8), partialResult);
}
}
} catch (InvalidProtocolBufferException e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
} catch (IOException e) {
System.err.println(e.getClass().getName() + ": " + e.getMessage());
}
List<Variant> results = new ArrayList<>(resultsMap.values());
return results;
}