Examples with FactorValue ubic.gemma.model.expression.experiment.FactorValue used on opensource projects

Example 16 with FactorValue

use of ubic.gemma.model.expression.experiment.FactorValue in project Gemma by PavlidisLab.

the class DifferentialExpressionAnalysisUtil method checkBiologicalReplicates.

/**
 * See if there are at least two samples for each factor value combination.
 *
 * @param expressionExperiment the experiment
 * @param factors              factors
 * @return true if there are replicates
 */
static boolean checkBiologicalReplicates(BioAssaySet expressionExperiment, Collection<ExperimentalFactor> factors) {
    Collection<BioMaterial> biomaterials = DifferentialExpressionAnalysisUtil.getBioMaterials(expressionExperiment);
    for (BioMaterial firstBm : biomaterials) {
        Collection<FactorValue> factorValuesToCheck = DifferentialExpressionAnalysisUtil.getRelevantFactorValues(factors, firstBm);
        boolean match = false;
        for (BioMaterial secondBm : biomaterials) {
            if (firstBm.equals(secondBm))
                continue;
            Collection<FactorValue> factorValuesToCompareTo = DifferentialExpressionAnalysisUtil.getRelevantFactorValues(factors, secondBm);
            if (factorValuesToCheck.size() == factorValuesToCompareTo.size() && factorValuesToCheck.containsAll(factorValuesToCompareTo)) {
                DifferentialExpressionAnalysisUtil.log.debug("Replicate found for biomaterial " + firstBm + ".");
                match = true;
                break;
            }
        }
        if (!match) {
            DifferentialExpressionAnalysisUtil.log.warn("No replicate found for biomaterial " + firstBm + ", with factor values" + StringUtils.join(factorValuesToCheck, ","));
            return false;
        }
    }
    return true;
}

Example 17 with FactorValue

use of ubic.gemma.model.expression.experiment.FactorValue in project Gemma by PavlidisLab.

the class CharacteristicUpdateTaskImpl method convertToFactorValuesWithCharacteristics.

/**
 * This is used to handle the special case of FactorValues that are being updated to have a characteristic.
 *
 * @return for each given AnnotationValueObject, the corresponding FactorValue with an associated persistent
 * Characteristic.
 * @throws IllegalStateException if the corresponding FactorValue already has at least one Characteristic. This
 *                               method is just intended for filling that in if it's empty.
 */
private Collection<FactorValue> convertToFactorValuesWithCharacteristics(Collection<AnnotationValueObject> avos) {
    Collection<FactorValue> result = new HashSet<>();
    for (AnnotationValueObject avo : avos) {
        if (avo.getObjectClass() == null || !avo.getObjectClass().equals(FactorValue.class.getSimpleName()))
            continue;
        if (avo.getId() == null) {
            log.warn("No id");
            continue;
        }
        /*
             * load the factor value, and create a characteristic
             */
        FactorValue fv = factorValueService.load(avo.getId());
        if (fv == null)
            continue;
        if (!fv.getCharacteristics().isEmpty()) {
            throw new IllegalStateException("Don't use the annotator to update factor values that already have characteristics");
        }
        VocabCharacteristic vc = convertAvo2Characteristic(avo);
        vc.setId(null);
        if (vc.getEvidenceCode() == null) {
            vc.setEvidenceCode(GOEvidenceCode.IC);
        }
        vc = (VocabCharacteristic) characteristicService.create(vc);
        fv.setValue(vc.getValue());
        fv.getCharacteristics().add(vc);
        result.add(fv);
    }
    return result;
}

Example 18 with FactorValue

use of ubic.gemma.model.expression.experiment.FactorValue in project Gemma by PavlidisLab.

the class CharacteristicUpdateTaskImpl method addToParent.

private void addToParent(Characteristic c, Object parent) {
    if (parent instanceof ExpressionExperiment) {
        ExpressionExperiment ee = (ExpressionExperiment) parent;
        ee = expressionExperimentService.thawLite(ee);
        ee.getCharacteristics().add(c);
        expressionExperimentService.update(ee);
    } else if (parent instanceof BioMaterial) {
        BioMaterial bm = (BioMaterial) parent;
        bm.getCharacteristics().add(c);
        bioMaterialService.update(bm);
    } else if (parent instanceof FactorValue) {
        FactorValue fv = (FactorValue) parent;
        fv.getCharacteristics().add(c);
        factorValueService.update(fv);
    }
}

Example 19 with FactorValue

use of ubic.gemma.model.expression.experiment.FactorValue in project Gemma by PavlidisLab.

the class CharacteristicUpdateTaskImpl method doUpdate.

private TaskResult doUpdate() {
    Collection<AnnotationValueObject> avos = taskCommand.getAnnotationValueObjects();
    if (avos.size() == 0)
        return new TaskResult(taskCommand, false);
    log.info("Updating " + avos.size() + " characteristics or uncharacterized factor values...");
    StopWatch timer = new StopWatch();
    timer.start();
    Collection<Characteristic> asChars = convertToCharacteristic(avos);
    Collection<FactorValue> factorValues = convertToFactorValuesWithCharacteristics(avos);
    if (asChars.size() == 0 && factorValues.size() == 0) {
        log.info("Nothing to update");
        return new TaskResult(taskCommand, false);
    }
    for (FactorValue factorValue : factorValues) {
        factorValueService.update(factorValue);
    }
    if (asChars.size() == 0)
        return new TaskResult(taskCommand, true);
    Map<Characteristic, Object> charToParent = characteristicService.getParents(asChars);
    for (Characteristic cFromClient : asChars) {
        Long characteristicId = cFromClient.getId();
        if (characteristicId == null) {
            continue;
        }
        Characteristic cFromDatabase = characteristicService.load(characteristicId);
        if (cFromDatabase == null) {
            log.warn("No such characteristic with id=" + characteristicId);
            continue;
        }
        VocabCharacteristic vcFromClient = (cFromClient instanceof VocabCharacteristic) ? (VocabCharacteristic) cFromClient : null;
        VocabCharacteristic vcFromDatabase = (cFromDatabase instanceof VocabCharacteristic) ? (VocabCharacteristic) cFromDatabase : null;
        /*
             * if one of the characteristics is a VocabCharacteristic and the other is not, we have to change the
             * characteristic in the database so that it matches the one from the client; since we can't change the
             * class of the object, we have to remove the old characteristic and make a new one of the appropriate
             * class.
             */
        Object parent = charToParent.get(cFromDatabase);
        /*
             * Check needed because Characteristics are not securable.
             */
        if (parent != null && Securable.class.isAssignableFrom(parent.getClass()) && !securityService.isEditable((Securable) parent)) {
            throw new AccessDeniedException("Access is denied");
        }
        if (vcFromClient != null && vcFromDatabase == null) {
            VocabCharacteristic vc = VocabCharacteristic.Factory.newInstance();
            vc.setValue(StringUtils.strip(cFromDatabase.getValue()));
            vc.setEvidenceCode(cFromDatabase.getEvidenceCode());
            vc.setDescription(cFromDatabase.getDescription());
            vc.setCategory(cFromDatabase.getCategory());
            vc.setName(cFromDatabase.getName());
            vcFromDatabase = (VocabCharacteristic) characteristicService.create(vc);
            removeFromParent(cFromDatabase, parent);
            characteristicService.remove(cFromDatabase);
            addToParent(vcFromDatabase, parent);
            cFromDatabase = vcFromDatabase;
        } else if (vcFromClient == null && vcFromDatabase != null) {
            // don't copy AuditTrail or Status to avoid cascade error... vcFromDatabase.getAuditTrail()
            cFromDatabase = characteristicService.create(Characteristic.Factory.newInstance(vcFromDatabase.getName(), vcFromDatabase.getDescription(), null, StringUtils.strip(vcFromDatabase.getValue()), vcFromDatabase.getCategory(), vcFromDatabase.getCategoryUri(), vcFromDatabase.getEvidenceCode()));
            removeFromParent(vcFromDatabase, parent);
            characteristicService.remove(vcFromDatabase);
            addToParent(cFromDatabase, parent);
        }
        /*
             * at this point, cFromDatabase points to the class-corrected characteristic in the database that must be
             * updated with the information coming from the client.
             */
        assert cFromDatabase != null;
        cFromDatabase.setValue(cFromClient.getValue());
        cFromDatabase.setCategory(cFromClient.getCategory());
        if (cFromDatabase instanceof VocabCharacteristic) {
            vcFromDatabase = (VocabCharacteristic) cFromDatabase;
            if (vcFromClient != null) {
                if (vcFromDatabase.getValueUri() == null || vcFromDatabase.getValueUri() == null || !vcFromDatabase.getValueUri().equals(vcFromClient.getValueUri())) {
                    log.info("Characteristic value update: " + vcFromDatabase + " " + vcFromDatabase.getValueUri() + " -> " + vcFromClient.getValueUri() + " associated with " + parent);
                    vcFromDatabase.setValueUri(vcFromClient.getValueUri());
                }
                if (vcFromDatabase.getCategory() == null || vcFromDatabase.getCategoryUri() == null || !vcFromDatabase.getCategoryUri().equals(vcFromClient.getCategoryUri())) {
                    log.info("Characteristic category update: " + vcFromDatabase + " " + vcFromDatabase.getCategoryUri() + " -> " + vcFromClient.getCategoryUri() + " associated with " + parent);
                    vcFromDatabase.setCategoryUri(vcFromClient.getCategoryUri());
                }
            }
        }
        if (cFromClient.getEvidenceCode() == null) {
            // characteristic has been manually updated
            cFromDatabase.setEvidenceCode(GOEvidenceCode.IC);
        } else {
            if (!cFromDatabase.getEvidenceCode().equals(cFromClient.getEvidenceCode())) {
                log.info("Characteristic evidence code update: " + cFromDatabase + " " + cFromDatabase.getEvidenceCode() + " -> " + cFromClient.getEvidenceCode());
            }
            // let them change it.
            cFromDatabase.setEvidenceCode(cFromClient.getEvidenceCode());
        }
        characteristicService.update(cFromDatabase);
    }
    timer.stop();
    if (timer.getTime() > 1000) {
        log.info("Update took: " + timer.getTime());
    }
    return new TaskResult(taskCommand, true);
}

Example 20 with FactorValue

use of ubic.gemma.model.expression.experiment.FactorValue in project Gemma by PavlidisLab.

the class ExpressionDataMatrixColumnSort method chunkOnFactor.

/**
 * Divide the biomaterials up into chunks based on the experimental factor given, keeping everybody in order. If the
 * factor is continuous, there is just one chunk.
 *
 * @return ordered map of fv->bm where fv is of ef, or null if it couldn't be done properly.
 */
private static LinkedHashMap<FactorValue, List<BioMaterial>> chunkOnFactor(ExperimentalFactor ef, List<BioMaterial> bms) {
    if (bms == null) {
        return null;
    }
    LinkedHashMap<FactorValue, List<BioMaterial>> chunks = new LinkedHashMap<>();
    /*
         * Get the factor values in the order we have things right now
         */
    for (BioMaterial bm : bms) {
        for (FactorValue fv : bm.getFactorValues()) {
            if (!ef.getFactorValues().contains(fv)) {
                continue;
            }
            if (chunks.keySet().contains(fv)) {
                continue;
            }
            chunks.put(fv, new ArrayList<BioMaterial>());
        }
    }
    /*
         * What if bm doesn't have a value for the factorvalue. Need a dummy value.
         */
    FactorValue dummy = FactorValue.Factory.newInstance(ef);
    dummy.setValue("");
    dummy.setId(-1L);
    chunks.put(dummy, new ArrayList<BioMaterial>());
    for (BioMaterial bm : bms) {
        boolean found = false;
        for (FactorValue fv : bm.getFactorValues()) {
            if (ef.getFactorValues().contains(fv)) {
                found = true;
                assert chunks.containsKey(fv);
                chunks.get(fv).add(bm);
            }
        }
        if (!found) {
            if (ExpressionDataMatrixColumnSort.log.isDebugEnabled())
                ExpressionDataMatrixColumnSort.log.debug(bm + " has no value for factor=" + ef + "; using dummy value");
            chunks.get(dummy).add(bm);
        }
    }
    if (chunks.get(dummy).size() == 0) {
        if (ExpressionDataMatrixColumnSort.log.isDebugEnabled())
            ExpressionDataMatrixColumnSort.log.debug("removing dummy");
        chunks.remove(dummy);
    }
    ExpressionDataMatrixColumnSort.log.debug(chunks.size() + " chunks for " + ef + ", from current chunk of size " + bms.size());
    /*
         * Sanity check
         */
    int total = 0;
    for (FactorValue fv : chunks.keySet()) {
        List<BioMaterial> chunk = chunks.get(fv);
        total += chunk.size();
    }
    assert total == bms.size() : "expected " + bms.size() + ", got " + total;
    return chunks;
}