Example usage for org.apache.solr.client.solrj SolrQuery setSort

Introduction

In this page you can find the example usage for org.apache.solr.client.solrj SolrQuery setSort.

Prototype

public SolrQuery setSort(String field, ORDER order) 

Source Link

Document

Replaces the current sort information with a single sort clause

Usage

From source file:org.mousephenotype.cda.solr.service.ObservationService.java

License:Apache License

/**
 *
 * @param p//from www  .  ja v a2  s . c o  m
 * @param genes
 * @param strains
 * @param biologicalSample
 * @return list of centers and sexes for the given parameters
 * @throws SolrServerException, IOException
 */
public Set<String> getCenters(Parameter p, List<String> genes, List<String> strains, String biologicalSample)
        throws SolrServerException, IOException {

    Set<String> centers = new HashSet<String>();
    SolrQuery query = new SolrQuery()
            .addFilterQuery(ObservationDTO.BIOLOGICAL_SAMPLE_GROUP + ":" + biologicalSample)
            .addFilterQuery(ObservationDTO.PARAMETER_STABLE_ID + ":" + p.getStableId());
    String q = (strains.size() > 1) ? "(" + ObservationDTO.STRAIN_ACCESSION_ID + ":\""
            + StringUtils.join(strains.toArray(), "\" OR " + ObservationDTO.STRAIN_ACCESSION_ID + ":\"") + "\")"
            : ObservationDTO.STRAIN_ACCESSION_ID + ":\"" + strains.get(0) + "\"";
    String fq = "";
    if (genes != null && genes.size() > 0) {
        fq += " (";
        fq += (genes.size() > 1) ? ObservationDTO.GENE_ACCESSION_ID + ":\""
                + StringUtils.join(genes.toArray(), "\" OR " + ObservationDTO.GENE_ACCESSION_ID + ":\"") + "\""
                : ObservationDTO.GENE_ACCESSION_ID + ":\"" + genes.get(0) + "\"";
        fq += ")";
    }
    query.addFilterQuery(fq);
    query.setQuery(q);
    query.setRows(100000000);
    query.setFields(ObservationDTO.GENE_ACCESSION_ID, ObservationDTO.DATA_POINT);
    query.set("group", true);
    query.set("group.field", ObservationDTO.PHENOTYPING_CENTER);
    query.setSort(ObservationDTO.ID, SolrQuery.ORDER.asc);

    List<Group> groups = experimentCore.query(query, METHOD.POST).getGroupResponse().getValues().get(0)
            .getValues();
    for (Group gr : groups) {
        centers.add((String) gr.getGroupValue());
    }

    return centers;
}

---

From source file:org.mousephenotype.cda.solr.service.ObservationService.java

License:Apache License

public CategoricalSet getCategories(Parameter parameter, List<String> genes, String biologicalSampleGroup,
        List<String> strains, String[] center, String[] sex)
        throws SolrServerException, IOException, SQLException {

    CategoricalSet resSet = new CategoricalSet();
    resSet.setName(biologicalSampleGroup);
    SolrQuery query = new SolrQuery()
            .addFilterQuery(ObservationDTO.BIOLOGICAL_SAMPLE_GROUP + ":" + biologicalSampleGroup)
            .addFilterQuery(ObservationDTO.PARAMETER_STABLE_ID + ":" + parameter.getStableId());

    String q = (strains.size() > 1) ? "(" + ObservationDTO.STRAIN_ACCESSION_ID + ":\""
            + StringUtils.join(strains.toArray(), "\" OR " + ObservationDTO.STRAIN_ACCESSION_ID + ":\"") + "\")"
            : ObservationDTO.STRAIN_ACCESSION_ID + ":\"" + strains.get(0) + "\"";

    if (genes != null && genes.size() > 0) {
        q += " AND (";
        q += (genes.size() > 1) ? ObservationDTO.GENE_ACCESSION_ID + ":\""
                + StringUtils.join(genes.toArray(), "\" OR " + ObservationDTO.GENE_ACCESSION_ID + ":\"") + "\""
                : ObservationDTO.GENE_ACCESSION_ID + ":\"" + genes.get(0) + "\"";
        q += ")";
    }//from w ww .  ja v  a  2  s.c o  m

    if (center != null && center.length > 0) {
        q += " AND (";
        q += (center.length > 1)
                ? ObservationDTO.PHENOTYPING_CENTER + ":\""
                        + StringUtils.join(center, "\" OR " + ObservationDTO.PHENOTYPING_CENTER + ":\"") + "\""
                : ObservationDTO.PHENOTYPING_CENTER + ":\"" + center[0] + "\"";
        q += ")";
    }

    if (sex != null && sex.length == 1) {
        q += " AND " + ObservationDTO.SEX + ":\"" + sex[0] + "\"";
    }

    query.setQuery(q);
    query.set("group.field", ObservationDTO.CATEGORY);
    query.set("group", true);
    query.setRows(100);
    query.setSort(ObservationDTO.ID, SolrQuery.ORDER.asc);

    logger.info("URL in getCategories " + SolrUtils.getBaseURL(experimentCore) + "/select?" + query);

    QueryResponse res = experimentCore.query(query, METHOD.POST);

    List<Group> groups = res.getGroupResponse().getValues().get(0).getValues();
    for (Group gr : groups) {
        CategoricalDataObject catObj = new CategoricalDataObject();
        catObj.setCount((long) gr.getResult().getNumFound());
        String catLabel = gr.getGroupValue();
        catObj.setCategory(catLabel);
        resSet.add(catObj);
    }
    return resSet;
}

---

From source file:org.mousephenotype.cda.solr.service.ObservationService.java

License:Apache License

/**
 * Get all controls for a specified set of center, strain, parameter,
 * (optional) sex, and metadata group./* w  w  w.  j a  va 2  s .  c om*/
 *
 * @param strain
 * @param experimentDate date of experiment
 * @param sex if null, both sexes are returned
 * @param metadataGroup when metadataGroup is empty string, force solr to
 * search for metadata_group:""
 * @return list of control observationDTOs that conform to the search
 * criteria
 * @throws SolrServerException, IOException
 */
public List<ObservationDTO> getAllControlsBySex(String parameterStableId, String strain,
        String phenotypingCenter, Date experimentDate, String sex, String metadataGroup)
        throws SolrServerException, IOException {

    List<ObservationDTO> results;

    QueryResponse response = new QueryResponse();

    SolrQuery query = new SolrQuery().setQuery("*:*")
            .addFilterQuery(ObservationDTO.BIOLOGICAL_SAMPLE_GROUP + ":control")
            .addFilterQuery(ObservationDTO.PARAMETER_STABLE_ID + ":" + parameterStableId)
            .addFilterQuery(ObservationDTO.STRAIN_ACCESSION_ID + ":" + strain.replace(":", "\\:")).setStart(0)
            .setRows(5000);
    query.setSort(ObservationDTO.ID, SolrQuery.ORDER.asc);
    if (phenotypingCenter != null) {
        query.addFilterQuery(ObservationDTO.PHENOTYPING_CENTER + ":\"" + phenotypingCenter + "\"");
    }

    if (metadataGroup == null) {
    } else if (metadataGroup.isEmpty()) {
        query.addFilterQuery(ObservationDTO.METADATA_GROUP + ":\"\"");
    } else {
        query.addFilterQuery(ObservationDTO.METADATA_GROUP + ":" + metadataGroup);
    }

    if (sex != null) {
        query.addFilterQuery(ObservationDTO.SEX + ":" + sex);
    }

    // Filter starting at 2000-01-01 and going through the end
    // of day on the experiment date
    if (experimentDate != null) {

        // Set time range to the last possible time on the day for SOLR
        // range query to include all observations on the same day
        Calendar cal = Calendar.getInstance();
        cal.setTime(DateUtils.addDays(experimentDate, 1));
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        Date maxDate = cal.getTime();

        Date beginning = new Date(946684800000L); // Start date (Jan 1 2000)
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
        String dateFilter = df.format(beginning) + "Z TO " + df.format(maxDate) + "Z";
        query.addFilterQuery(ObservationDTO.DATE_OF_EXPERIMENT + ":[" + dateFilter + "]");
    }
    response = experimentCore.query(query);
    results = response.getBeans(ObservationDTO.class);
    logger.debug("getAllControlsBySex " + query);
    return results;
}

---

From source file:org.mousephenotype.cda.solr.service.ObservationService.java

License:Apache License

/**
 * Returns a list of <code>ObservationDTO</code> observations for the specified procedureStableId and biologicalSampleId.
  *//w w  w .  ja  v a2s .c om
 * @param procedureStableId the procedure stable id (e.g. "IMPC_CAL_*" or "IMPC_IPP_*")
 * @param biologicalSampleId the biological sample id (mouse id) of the desired mouse
 *
 * @return a list of <code>ObservationDTO</code> calorimetry results for the specified mouse.
 *
 * @throws SolrServerException, IOException
 */
public List<ObservationDTO> getMetabolismReportBiologicalSampleId(String procedureStableId,
        Integer biologicalSampleId) throws SolrServerException, IOException {
    SolrQuery query = new SolrQuery();

    query.setFields(ObservationDTO.ALLELE_ACCESSION_ID, ObservationDTO.ALLELE_SYMBOL,
            ObservationDTO.BIOLOGICAL_SAMPLE_GROUP, ObservationDTO.BIOLOGICAL_SAMPLE_ID,
            ObservationDTO.COLONY_ID, ObservationDTO.DATA_POINT, ObservationDTO.DATE_OF_EXPERIMENT,
            ObservationDTO.DISCRETE_POINT, ObservationDTO.EXTERNAL_SAMPLE_ID, ObservationDTO.GENE_ACCESSION_ID,
            ObservationDTO.GENE_SYMBOL, ObservationDTO.METADATA, ObservationDTO.METADATA_GROUP,
            ObservationDTO.OBSERVATION_TYPE, ObservationDTO.PARAMETER_STABLE_ID,
            ObservationDTO.PHENOTYPING_CENTER, ObservationDTO.PROCEDURE_STABLE_ID, ObservationDTO.SEX,
            ObservationDTO.TIME_POINT, ObservationDTO.WEIGHT, ObservationDTO.ZYGOSITY);
    query.setRows(5000);
    query.setSort(ObservationDTO.ID, SolrQuery.ORDER.asc);
    query.setFilterQueries(ObservationDTO.PROCEDURE_STABLE_ID + ":" + procedureStableId);
    query.setQuery(ObservationDTO.BIOLOGICAL_SAMPLE_ID + ":" + biologicalSampleId);

    return experimentCore.query(query).getBeans(ObservationDTO.class);
}

---

From source file:org.mousephenotype.cda.solr.service.ObservationService.java

License:Apache License

/**
 * @author tudose//ww  w. ja  va 2 s .  c om
 * @date 2015/07/08
 * @param alleleAccession
 * @param phenotypingCenter
 * @param resource
 * @return List of pipelines with data for the given parameters.
 * @throws SolrServerException, IOException
 */
public List<ImpressBaseDTO> getPipelines(String alleleAccession, String phenotypingCenter,
        List<String> resource) throws SolrServerException, IOException {

    List<ImpressBaseDTO> pipelines = new ArrayList<>();

    SolrQuery query = new SolrQuery().setQuery("*:*")
            .addFilterQuery(ObservationDTO.ALLELE_ACCESSION_ID + ":\"" + alleleAccession + "\"")
            .addField(ObservationDTO.PIPELINE_ID).addField(ObservationDTO.PIPELINE_NAME)
            .addField(ObservationDTO.PIPELINE_STABLE_ID);
    if (phenotypingCenter != null) {
        query.addFilterQuery(ObservationDTO.PHENOTYPING_CENTER + ":\"" + phenotypingCenter + "\"");
    }
    if (resource != null) {
        query.addFilterQuery(ObservationDTO.DATASOURCE_NAME + ":\""
                + StringUtils.join(resource, "\" OR " + ObservationDTO.PHENOTYPING_CENTER + ":\"") + "\"");
    }

    query.set("group", true);
    query.set("group.field", ObservationDTO.PIPELINE_STABLE_ID);
    query.setRows(10000);
    query.setSort(ObservationDTO.ID, SolrQuery.ORDER.asc);
    query.set("group.limit", 1);

    logger.info("SOLR URL getPipelines " + SolrUtils.getBaseURL(experimentCore) + "/select?" + query);

    QueryResponse response = experimentCore.query(query);

    for (Group group : response.getGroupResponse().getValues().get(0).getValues()) {

        SolrDocument doc = group.getResult().get(0);
        ImpressBaseDTO pipeline = new ImpressBaseDTO();
        pipeline.setId(Long.getLong(doc.getFirstValue(ObservationDTO.PIPELINE_ID).toString()));
        pipeline.setStableId(doc.getFirstValue(ObservationDTO.PIPELINE_STABLE_ID).toString());
        pipeline.setName(doc.getFirstValue(ObservationDTO.PIPELINE_NAME).toString());
        pipelines.add(pipeline);

    }

    return pipelines;
}

---

From source file:org.mousephenotype.cda.solr.service.StatisticalResultService.java

License:Apache License

/**
 * @author tudose/*  www. j  av a 2  s.c om*/
 * @since 2015/07/21
 * @return List<ProcedureBean>
 */
public List<ImpressBaseDTO> getProcedures(String pipelineStableId, String observationType, String resource,
        Integer minParameterNumber, List<String> proceduresToSkip, String status, boolean includeWilcoxon) {

    List<ImpressBaseDTO> procedures = new ArrayList<>();

    try {
        SolrQuery query = new SolrQuery().setQuery("*:*").addField(StatisticalResultDTO.PROCEDURE_ID)
                .addField(StatisticalResultDTO.PROCEDURE_NAME)
                .addField(StatisticalResultDTO.PROCEDURE_STABLE_ID);
        query.set("group", true);
        query.set("group.field", StatisticalResultDTO.PROCEDURE_NAME);
        query.setRows(10000);
        query.setSort(StatisticalResultDTO.DOCUMENT_ID, SolrQuery.ORDER.asc);
        query.set("group.limit", 1);
        if (!includeWilcoxon) {
            query.addFilterQuery("-" + StatisticalResultDTO.STATISTICAL_METHOD + ":Wilcoxon*");
        }
        if (pipelineStableId != null) {
            query.addFilterQuery(StatisticalResultDTO.PIPELINE_STABLE_ID + ":" + pipelineStableId);
        }
        if (observationType != null) {
            query.addFilterQuery(StatisticalResultDTO.DATA_TYPE + ":" + observationType);
        }
        if (resource != null) {
            query.addFilterQuery(StatisticalResultDTO.RESOURCE_NAME + ":" + resource);
        }
        if (status != null) {
            query.addFilterQuery(StatisticalResultDTO.STATUS + ":" + status);
        }
        String pivotField = StatisticalResultDTO.PROCEDURE_NAME + "," + StatisticalResultDTO.PARAMETER_NAME;

        if (minParameterNumber != null && minParameterNumber > 0) {

            query.setFacet(true);
            query.setFacetMinCount(1);
            query.set("facet.pivot.mincount", minParameterNumber);
            query.set("facet.pivot", pivotField);

        }

        QueryResponse response = statisticalResultCore.query(query);

        for (Group group : response.getGroupResponse().getValues().get(0).getValues()) {

            ImpressBaseDTO procedure = new ImpressBaseDTO(
                    Long.getLong(group.getResult().get(0).getFirstValue(StatisticalResultDTO.PROCEDURE_ID)
                            .toString()),
                    null,
                    group.getResult().get(0).getFirstValue(StatisticalResultDTO.PROCEDURE_STABLE_ID).toString(),
                    group.getResult().get(0).getFirstValue(StatisticalResultDTO.PROCEDURE_NAME).toString());
            procedures.add(procedure);
        }

        if (minParameterNumber != null && minParameterNumber > 0) {
            // get procedureList with more than minParameterNumber
            // remove from procedures the ones not in procedureList
            List<Map<String, String>> res = getFacetPivotResults(response, false);
            HashSet<String> proceduresWithMinCount = new HashSet<>();

            for (Map<String, String> pivot : res) {
                proceduresWithMinCount.addAll(pivot.values());
            }

            List<ImpressBaseDTO> proceduresToReturn = new ArrayList<>();

            for (ImpressBaseDTO proc : procedures) {
                if (proceduresWithMinCount.contains(proc.getName())) {
                    if (proceduresToSkip != null && !proceduresToSkip.contains(proc.getStableId())
                            || proceduresToSkip == null) {
                        proceduresToReturn.add(proc);
                    }
                }
            }
            procedures = proceduresToReturn;

        }

    } catch (SolrServerException | IOException | IndexOutOfBoundsException e) {
        e.printStackTrace();
    }

    return procedures;
}

---

From source file:org.mousephenotype.cda.solr.service.StatisticalResultService.java

License:Apache License

public TreeMap<String, ParallelCoordinatesDTO> getGenotypeEffectFor(List<String> procedureStableId,
        List<String> phenotypingCenters, Boolean requiredParamsOnly, String baseUrl, List<String> genes,
        String topLevelMpId) throws SolrServerException, IOException, URISyntaxException {

    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    if (procedureStableId != null) {
        query.addFilterQuery(StatisticalResultDTO.PROCEDURE_STABLE_ID + ":"
                + StringUtils.join(procedureStableId, "* OR " + StatisticalResultDTO.PROCEDURE_STABLE_ID + ":")
                + "*");
    }//from   w  ww  . ja  va2  s .c  om
    query.addFilterQuery(StatisticalResultDTO.DATA_TYPE + ":unidimensional");
    query.setFacet(true);
    query.setFacetMinCount(1);
    query.setFacetLimit(-1);
    query.addFacetField(StatisticalResultDTO.PARAMETER_STABLE_ID);
    query.addFacetField(StatisticalResultDTO.PARAMETER_NAME);

    if (phenotypingCenters != null && phenotypingCenters.size() > 0) {
        query.addFilterQuery(StatisticalResultDTO.PHENOTYPING_CENTER + ":\"" + StringUtils
                .join(phenotypingCenters, "\" OR " + StatisticalResultDTO.PHENOTYPING_CENTER + ":\"") + "\"");
    }

    List<String> parameterStableIds = new ArrayList<>(getFacets(statisticalResultCore.query(query))
            .get(StatisticalResultDTO.PARAMETER_STABLE_ID).keySet());
    TreeSet<ParameterDTO> parameterUniqueByStableId = new TreeSet<>(ParameterDTO.getComparatorByName());

    for (ParameterDTO param : impressService.getParameters(procedureStableId, "unidimensional", topLevelMpId)) {
        if (parameterStableIds.contains(param.getStableId()) && (param.isRequired() || !requiredParamsOnly)
                && !parameterUniqueByStableId.contains(param)) {
            parameterUniqueByStableId.add(param);
        }
    }

    List<ParameterDTO> parameters = new ArrayList<>(parameterUniqueByStableId);
    Map<String, ParameterDTO> parameterMap = new HashMap<>();
    for (ParameterDTO p : parameterUniqueByStableId) {
        parameterMap.put(p.getStableId(), p);
    }

    query = new SolrQuery();
    query.setQuery("-" + StatisticalResultDTO.STATISTICAL_METHOD + ":Wilcoxon*"); // Decided to omit Wilcoxon because it does not adjust for batch or center effect and the value for genotyope effect does not have the same meaning as for the other values.
    query.addFilterQuery(StatisticalResultDTO.PARAMETER_STABLE_ID + ":\""
            + StringUtils.join(parameters.stream().map(ParameterDTO::getStableId).collect(Collectors.toList()),
                    "\" OR " + StatisticalResultDTO.PARAMETER_STABLE_ID + ":\"")
            + "\"");
    query.addFilterQuery(StatisticalResultDTO.STATUS + ":Success");

    query.addField(StatisticalResultDTO.GENOTYPE_EFFECT_PARAMETER_ESTIMATE);
    query.addField(StatisticalResultDTO.MARKER_ACCESSION_ID);
    query.addField(StatisticalResultDTO.PARAMETER_STABLE_ID);
    query.addField(StatisticalResultDTO.FEMALE_KO_PARAMETER_ESTIMATE);
    query.addField(StatisticalResultDTO.MALE_KO_PARAMETER_ESTIMATE);
    query.addField(StatisticalResultDTO.PHENOTYPING_CENTER);
    query.addField(StatisticalResultDTO.PROCEDURE_NAME);
    query.addField(StatisticalResultDTO.MARKER_SYMBOL);
    query.addField(StatisticalResultDTO.SIGNIFICANT);
    query.setRows(Integer.MAX_VALUE);
    query.setSort(StatisticalResultDTO.DOCUMENT_ID, SolrQuery.ORDER.asc);

    if (phenotypingCenters != null && phenotypingCenters.size() > 0) {
        query.addFilterQuery(StatisticalResultDTO.PHENOTYPING_CENTER + ":\"" + StringUtils
                .join(phenotypingCenters, "\" OR " + StatisticalResultDTO.PHENOTYPING_CENTER + ":\"") + "\"");
    }

    if (genes != null) {
        query.addFilterQuery(StatisticalResultDTO.MARKER_SYMBOL + ":(\""
                + genes.stream().collect(Collectors.joining("\" OR \"")) + "\")");
    }

    List<StatisticalResultDTO> result = statisticalResultCore.query(query, SolrRequest.METHOD.POST)
            .getBeans(StatisticalResultDTO.class);
    TreeMap<String, ParallelCoordinatesDTO> row = addMaxGenotypeEffects(result, parameterMap, baseUrl);
    row = addMeanValues(row, parameters);
    row = addDefaultValues(row, parameters); // add normal/no effect values after mean so that they're not used in the computation

    return row;

}

---

From source file:org.mousephenotype.cda.solr.service.StatisticalResultService.java

License:Apache License

public StackedBarsData getUnidimensionalData(Parameter p, List<String> genes, List<String> strains,
        String biologicalSample, String[] center, String[] sex) throws SolrServerException, IOException {

    String urlParams = "";
    SolrQuery query = new SolrQuery()
            .addFilterQuery(StatisticalResultDTO.PARAMETER_STABLE_ID + ":" + p.getStableId());
    String q = "*:*";
    query.addFilterQuery((strains.size() > 1)
            ? "(" + StatisticalResultDTO.STRAIN_ACCESSION_ID + ":\""
                    + StringUtils.join(strains.toArray(),
                            "\" OR " + StatisticalResultDTO.STRAIN_ACCESSION_ID + ":\"")
                    + "\")"
            : StatisticalResultDTO.STRAIN_ACCESSION_ID + ":\"" + strains.get(0) + "\"");
    if (strains.size() > 0) {
        urlParams += "&strain=" + StringUtils.join(strains.toArray(), "&strain=");
    }/*from   w  ww  .  j a  va2  s  .  c o m*/

    if (center != null && center.length > 0) {
        query.addFilterQuery(
                "(" + ((center.length > 1)
                        ? StatisticalResultDTO.PHENOTYPING_CENTER + ":\""
                                + StringUtils.join(center,
                                        "\" OR " + StatisticalResultDTO.PHENOTYPING_CENTER + ":\"")
                                + "\""
                        : StatisticalResultDTO.PHENOTYPING_CENTER + ":\"" + center[0] + "\"") + ")");
        urlParams += "&phenotyping_center=" + StringUtils.join(center, "&phenotyping_center=");
    }

    if (sex != null && sex.length == 1) {
        if (sex[0].equalsIgnoreCase("male")) {
            query.addFilterQuery(StatisticalResultDTO.MALE_CONTROL_COUNT + ":[4 TO 100000]");
            query.addFilterQuery(StatisticalResultDTO.MALE_MUTANT_COUNT + ":[4 TO 100000]");
        } else {
            query.addFilterQuery(StatisticalResultDTO.FEMALE_CONTROL_COUNT + ":[4 TO 100000]");
            query.addFilterQuery(StatisticalResultDTO.FEMALE_MUTANT_COUNT + ":[4 TO 100000]");
        }
    }

    query.setQuery(q);
    query.addFilterQuery("(" + StatisticalResultDTO.FEMALE_CONTROL_COUNT + ":[4 TO 100000] OR "
            + StatisticalResultDTO.MALE_CONTROL_COUNT + ":[4 TO 100000])");
    query.setRows(10000000);
    query.setSort(StatisticalResultDTO.DOCUMENT_ID, SolrQuery.ORDER.asc);
    query.setFields(StatisticalResultDTO.MARKER_ACCESSION_ID, StatisticalResultDTO.FEMALE_CONTROL_MEAN,
            StatisticalResultDTO.MARKER_SYMBOL, StatisticalResultDTO.FEMALE_MUTANT_MEAN,
            StatisticalResultDTO.MALE_CONTROL_MEAN, StatisticalResultDTO.MALE_MUTANT_MEAN,
            StatisticalResultDTO.FEMALE_CONTROL_COUNT, StatisticalResultDTO.FEMALE_MUTANT_COUNT,
            StatisticalResultDTO.MALE_CONTROL_COUNT, StatisticalResultDTO.MALE_MUTANT_COUNT);
    query.set("group", true);
    query.set("group.field", StatisticalResultDTO.COLONY_ID);
    query.set("group.limit", 1);

    List<Group> groups = statisticalResultCore.query(query).getGroupResponse().getValues().get(0).getValues();
    double[] meansArray = new double[groups.size()];
    String[] genesArray = new String[groups.size()];
    String[] geneSymbolArray = new String[groups.size()];
    int size = 0;

    for (Group gr : groups) {

        SolrDocumentList resDocs = gr.getResult();
        String sexToDisplay = null;
        OverviewRatio overviewRatio = new OverviewRatio();

        for (SolrDocument doc : resDocs) {
            sexToDisplay = getSexToDisplay(sex, sexToDisplay, doc);
            overviewRatio.add(doc);
        }

        if (sexToDisplay != null) {
            Double ratio = overviewRatio.getPlotRatio(sexToDisplay);
            if (ratio != null) {
                genesArray[size] = (String) resDocs.get(0).get(StatisticalResultDTO.MARKER_ACCESSION_ID);
                geneSymbolArray[size] = (String) resDocs.get(0).get(StatisticalResultDTO.MARKER_SYMBOL);
                meansArray[size] = ratio;
                size++;
            }
        }
    }

    // we do the binning for all the data but fill the bins after that to
    // keep tract of phenotype associations
    int binCount = Math.min((int) Math.floor((double) groups.size() / 2), 20);
    List<String> mutantGenes = new ArrayList<>();
    List<String> controlGenes = new ArrayList<>();
    List<String> mutantGeneAcc = new ArrayList<>();
    List<String> controlGeneAcc = new ArrayList<>();
    List<Double> upperBounds = new ArrayList<>();
    EmpiricalDistribution distribution = new EmpiricalDistribution(binCount);
    if (size > 0) {
        distribution.load(ArrayUtils.subarray(meansArray, 0, size - 1));
        for (double bound : distribution.getUpperBounds()) {
            upperBounds.add(bound);
        }
        // we we need to distribute the control mutants and the
        // phenotype-mutants in the bins
        List<Double> controlM = new ArrayList<>();
        List<Double> phenMutants = new ArrayList<>();

        for (int j = 0; j < upperBounds.size(); j++) {
            controlM.add((double) 0);
            phenMutants.add((double) 0);
            controlGenes.add("");
            mutantGenes.add("");
            controlGeneAcc.add("");
            mutantGeneAcc.add("");
        }

        for (int j = 0; j < size; j++) {
            // find out the proper bin
            int binIndex = getBin(upperBounds, meansArray[j]);
            if (genes.contains(genesArray[j])) {
                phenMutants.set(binIndex, 1 + phenMutants.get(binIndex));
                String genesString = mutantGenes.get(binIndex);
                if (!genesString.contains(geneSymbolArray[j])) {
                    if (genesString.equals("")) {
                        mutantGenes.set(binIndex, geneSymbolArray[j]);
                        mutantGeneAcc.set(binIndex, "accession=" + genesArray[j]);
                    } else {
                        mutantGenes.set(binIndex, genesString + ", " + geneSymbolArray[j]);
                        mutantGeneAcc.set(binIndex,
                                mutantGeneAcc.get(binIndex) + "&accession=" + genesArray[j]);
                    }
                }
            } else { // treat as control because they don't have this phenotype association
                String genesString = controlGenes.get(binIndex);
                if (!genesString.contains(geneSymbolArray[j])) {
                    if (genesString.equalsIgnoreCase("")) {
                        controlGenes.set(binIndex, geneSymbolArray[j]);
                        controlGeneAcc.set(binIndex, "accession=" + genesArray[j]);
                    } else {
                        controlGenes.set(binIndex, genesString + ", " + geneSymbolArray[j]);
                        controlGeneAcc.set(binIndex,
                                controlGeneAcc.get(binIndex) + "&accession=" + genesArray[j]);
                    }
                }
                controlM.set(binIndex, 1 + controlM.get(binIndex));
            }
        }

        // add the rest of parameters to the graph urls
        for (int t = 0; t < controlGeneAcc.size(); t++) {
            controlGeneAcc.set(t, controlGeneAcc.get(t) + urlParams);
            mutantGeneAcc.set(t, mutantGeneAcc.get(t) + urlParams);
        }

        StackedBarsData data = new StackedBarsData();
        data.setUpperBounds(upperBounds);
        data.setControlGenes(controlGenes);
        data.setControlMutatns(controlM);
        data.setMutantGenes(mutantGenes);
        data.setPhenMutants(phenMutants);
        data.setControlGeneAccesionIds(controlGeneAcc);
        data.setMutantGeneAccesionIds(mutantGeneAcc);
        return data;
    }

    return null;
}

---

From source file:org.mousephenotype.cda.solr.service.StatisticalResultService.java

License:Apache License

/**
 *
 * @param gene//from  w  w  w. j  av  a2  s.  c  o m
 * @param zygosity
 * @return SolrDocumentList grouped by top level MP term
 * @throws SolrServerException, IOException
 * @author ilinca
 */
public HashMap<String, List<StatisticalResultDTO>> getPhenotypesForTopLevelTerm(String gene,
        ZygosityType zygosity) throws SolrServerException, IOException {

    HashMap<String, List<StatisticalResultDTO>> res = new HashMap<>();
    String query = "*:*";

    if (gene.equalsIgnoreCase("*")) {
        query = StatisticalResultDTO.MARKER_ACCESSION_ID + ":" + gene;
    } else {
        query = StatisticalResultDTO.MARKER_ACCESSION_ID + ":\"" + gene + "\"";
    }

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery(query);
    solrQuery.setRows(Integer.MAX_VALUE);
    solrQuery.setSort(StatisticalResultDTO.P_VALUE, ORDER.asc);
    solrQuery.addFilterQuery(StringUtils.join(Arrays.asList(StatisticalResultDTO.MP_TERM_ID + ":*",
            StatisticalResultDTO.FEMALE_MP_TERM_ID + ":*", StatisticalResultDTO.MALE_MP_TERM_ID + ":*"),
            " OR "));
    solrQuery.addFilterQuery(StatisticalResultDTO.STATUS + ":Success");
    solrQuery.setFields(StatisticalResultDTO.P_VALUE, StatisticalResultDTO.SEX, StatisticalResultDTO.ZYGOSITY,
            StatisticalResultDTO.MARKER_ACCESSION_ID, StatisticalResultDTO.MARKER_SYMBOL,
            StatisticalResultDTO.MP_TERM_ID, StatisticalResultDTO.MP_TERM_NAME,
            StatisticalResultDTO.TOP_LEVEL_MP_TERM_ID, StatisticalResultDTO.TOP_LEVEL_MP_TERM_NAME,
            StatisticalResultDTO.FEMALE_TOP_LEVEL_MP_TERM_ID,
            StatisticalResultDTO.FEMALE_TOP_LEVEL_MP_TERM_NAME, StatisticalResultDTO.MALE_TOP_LEVEL_MP_TERM_ID,
            StatisticalResultDTO.MALE_TOP_LEVEL_MP_TERM_NAME, StatisticalResultDTO.PHENOTYPE_SEX,
            StatisticalResultDTO.RESOURCE_NAME, StatisticalResultDTO.PROCEDURE_STABLE_ID,
            StatisticalResultDTO.SIGNIFICANT);

    if (zygosity != null) {
        solrQuery.addFilterQuery(StatisticalResultDTO.ZYGOSITY + ":" + zygosity.getName());
    }
    System.out.println("solrQuery=" + solrQuery);
    List<StatisticalResultDTO> dtos = statisticalResultCore.query(solrQuery)
            .getBeans(StatisticalResultDTO.class);
    System.out.println("SRDTOS size for " + zygosity.getName() + "=" + dtos.size());

    for (StatisticalResultDTO dto : dtos) {
        if (dto.getTopLevelMpTermId() != null || dto.getFemaleTopLevelMpTermId() != null
                || dto.getMaleTopLevelMpTermId() != null) {

            // Collect all the top level terms into a single list
            List<String> topLevelTermIds = Stream
                    .of(dto.getTopLevelMpTermId(), dto.getFemaleTopLevelMpTermId(),
                            dto.getMaleTopLevelMpTermId())
                    .filter(Objects::nonNull).flatMap(Collection::stream).collect(Collectors.toList());

            for (String id : topLevelTermIds) {
                if (!res.containsKey(id)) {
                    res.put(id, new ArrayList<>());
                }

                res.get(id).add(dto);
            }

        } else if (dto.getMpTermId() != null) {

            String id = dto.getMpTermId();
            if (!res.containsKey(id)) {
                res.put(id, new ArrayList<>());
            }
            res.get(id).add(dto);

        }
    }
    return res;
}

---

From source file:org.mousephenotype.cda.solr.service.StatisticalResultService.java

License:Apache License

public PhenotypeFacetResult getPhenotypeFacetResultByPhenotypingCenterAndPipeline(String phenotypingCenter,
        String pipelineStableId) throws IOException, URISyntaxException, JSONException {

    SolrQuery query = new SolrQuery();
    query.setQuery(StatisticalResultDTO.PHENOTYPING_CENTER + ":\"" + phenotypingCenter);
    query.addFilterQuery(StatisticalResultDTO.PIPELINE_STABLE_ID + ":" + pipelineStableId);
    query.setFacet(true);/*  ww w.ja va  2s  .  com*/
    query.addFacetField(StatisticalResultDTO.RESOURCE_FULLNAME);
    query.addFacetField(StatisticalResultDTO.PROCEDURE_NAME);
    query.addFacetField(StatisticalResultDTO.MARKER_SYMBOL);
    query.addFacetField(StatisticalResultDTO.MP_TERM_NAME);
    query.setSort(StatisticalResultDTO.P_VALUE, SolrQuery.ORDER.asc);
    query.setRows(10000000);
    query.set("wt", "json");
    query.set("version", "2.2");

    String solrUrl = SolrUtils.getBaseURL(statisticalResultCore) + "/select?" + query;
    return createPhenotypeResultFromSolrResponse(solrUrl);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »