Examples with TaxonList dr.evolution.util.TaxonList used on opensource projects

Example 41 with TaxonList

use of dr.evolution.util.TaxonList in project beast-mcmc by beast-dev.

the class TipDateSamplingComponentOptions method selectParameters.

public void selectParameters(final ModelOptions modelOptions, final List<Parameter> params) {
    if (tipDateSamplingType == TipDateSamplingType.SAMPLE_INDIVIDUALLY || tipDateSamplingType == TipDateSamplingType.SAMPLE_PRECISION) {
        TaxonList taxa = getTaxonSet();
        for (int i = 0; i < taxa.getTaxonCount(); i++) {
            Taxon taxon = taxa.getTaxon(i);
            Parameter parameter = getTipDateParameter(taxon);
            if (tipDateSamplingType != TipDateSamplingType.SAMPLE_PRECISION) {
                // no explicit priors when sampling from precisions - the random walk operators
                // sample uniformly from within the bounds defined by the precision.
                params.add(parameter);
            }
        }
    } else if (tipDateSamplingType == TipDateSamplingType.SAMPLE_JOINT) {
        params.add(modelOptions.getParameter("treeModel.tipDates"));
    }
}

Example 42 with TaxonList

use of dr.evolution.util.TaxonList in project beast-mcmc by beast-dev.

the class TipDateSamplingComponentOptions method getTaxonSet.

public TaxonList getTaxonSet() {
    TaxonList taxa = options.taxonList;
    if (tipDateSamplingTaxonSet != null) {
        taxa = tipDateSamplingTaxonSet;
    }
    if (tipDateSamplingType == TipDateSamplingType.SAMPLE_PRECISION) {
        Taxa precisionTaxonList = new Taxa();
        for (int i = 0; i < taxa.getTaxonCount(); i++) {
            Taxon taxon = taxa.getTaxon(i);
            Date date = taxon.getDate();
            if (date.getPrecision() > 0.0) {
                precisionTaxonList.addTaxon(taxon);
            }
        }
        taxa = precisionTaxonList;
    }
    return taxa;
}

Example 43 with TaxonList

use of dr.evolution.util.TaxonList in project beast-mcmc by beast-dev.

the class BeastGenerator method checkOptions.

/**
     * Checks various options to check they are valid. Throws IllegalArgumentExceptions with
     * descriptions of the problems.
     *
     * @throws IllegalArgumentException if there is a problem with the current settings
     */
public void checkOptions() throws GeneratorException {
    try {
        if (options.contains(Microsatellite.INSTANCE)) {
            // clear all masks
            for (PartitionPattern partitionPattern : options.getPartitionPattern()) {
                partitionPattern.getPatterns().clearMask();
            }
            // set mask
            for (PartitionTreeModel model : options.getPartitionTreeModels()) {
                // if a tree only has 1 data partition, which mostly mean unlinked trees
                if (options.getDataPartitions(model).size() == 1) {
                    PartitionPattern partition = (PartitionPattern) options.getDataPartitions(model).get(0);
                    Patterns patterns = partition.getPatterns();
                    for (int i = 0; i < patterns.getTaxonCount(); i++) {
                        int state = patterns.getPatternState(i, 0);
                        // mask ? from data
                        if (state < 0) {
                            patterns.addMask(i);
                        }
                    }
                //                        System.out.println("mask set = " + patterns.getMaskSet() + " in partition " + partition.getName());
                }
            }
        }
        //++++++++++++++++ Taxon List ++++++++++++++++++
        TaxonList taxonList = options.taxonList;
        Set<String> ids = new HashSet<String>();
        ids.add(TaxaParser.TAXA);
        ids.add(AlignmentParser.ALIGNMENT);
        ids.add(TraitData.TRAIT_SPECIES);
        if (taxonList != null) {
            if (taxonList.getTaxonCount() < 2) {
                throw new GeneratorException("BEAST requires at least two taxa to run.");
            }
            for (int i = 0; i < taxonList.getTaxonCount(); i++) {
                Taxon taxon = taxonList.getTaxon(i);
                if (ids.contains(taxon.getId())) {
                    throw new GeneratorException("A taxon has the same id," + taxon.getId() + MESSAGE_CAL);
                }
                ids.add(taxon.getId());
            }
        }
        //++++++++++++++++ Taxon Sets ++++++++++++++++++
        for (PartitionTreeModel model : options.getPartitionTreeModels()) {
            // should be only 1 calibrated internal node with a proper prior and monophyletic for each tree at moment
            if (model.getPartitionTreePrior().getNodeHeightPrior() == TreePriorType.YULE_CALIBRATION) {
                if (// invalid node calibration
                options.treeModelOptions.isNodeCalibrated(model) < 0)
                    throw new GeneratorException(MESSAGE_CAL_YULE);
                if (options.treeModelOptions.isNodeCalibrated(model) > 0) {
                    // internal node calibration
                    List taxonSetsList = options.getKeysFromValue(options.taxonSetsTreeModel, model);
                    if (taxonSetsList.size() != 1 || !options.taxonSetsMono.get(taxonSetsList.get(0))) {
                        // 1 tmrca per tree && monophyletic
                        throw new GeneratorException(MESSAGE_CAL_YULE, BeautiFrame.TAXON_SETS);
                    }
                }
            }
        }
        for (Taxa taxa : options.taxonSets) {
            // AR - we should allow single taxon taxon sets...
            if (// && !options.taxonSetsIncludeStem.get(taxa)
            taxa.getTaxonCount() < 1) {
                throw new GeneratorException("Taxon set, " + taxa.getId() + ", should contain \n" + "at least one taxa. Please go back to Taxon Sets \n" + "panel to correct this.", BeautiFrame.TAXON_SETS);
            }
            if (ids.contains(taxa.getId())) {
                throw new GeneratorException("A taxon set has the same id," + taxa.getId() + MESSAGE_CAL, BeautiFrame.TAXON_SETS);
            }
            ids.add(taxa.getId());
        }
        //++++++++++++++++ *BEAST ++++++++++++++++++
        if (options.useStarBEAST) {
            if (!options.traitExists(TraitData.TRAIT_SPECIES))
                throw new GeneratorException("A trait labelled \"species\" is required for *BEAST species designations." + "\nPlease create or import the species designations in the Traits table.", BeautiFrame.TRAITS);
            // should be only 1 calibrated internal node with monophyletic at moment
            if (options.getPartitionTreePriors().get(0).getNodeHeightPrior() == TreePriorType.SPECIES_YULE_CALIBRATION) {
                if (options.speciesSets.size() != 1 || !options.speciesSetsMono.get(options.speciesSets.get(0))) {
                    throw new GeneratorException(MESSAGE_CAL_YULE, BeautiFrame.TAXON_SETS);
                }
            }
            for (Taxa species : options.speciesSets) {
                if (species.getTaxonCount() < 2) {
                    throw new GeneratorException("Species set, " + species.getId() + ",\n should contain" + "at least two species. \nPlease go back to Species Sets panel to select included species.", BeautiFrame.TAXON_SETS);
                }
                if (ids.contains(species.getId())) {
                    throw new GeneratorException("A species set has the same id," + species.getId() + MESSAGE_CAL, BeautiFrame.TAXON_SETS);
                }
                ids.add(species.getId());
            }
            int tId = options.starBEASTOptions.getEmptySpeciesIndex();
            if (tId >= 0) {
                throw new GeneratorException("The taxon " + options.taxonList.getTaxonId(tId) + " has NULL value for \"species\" trait", BeautiFrame.TRAITS);
            }
        }
        //        if (options.isShareSameTreePrior()) {
        if (options.getPartitionTreeModels().size() > 1) {
            //TODO not allowed multi-prior yet
            for (PartitionTreePrior prior : options.getPartitionTreePriors()) {
                if (prior.getNodeHeightPrior() == TreePriorType.GMRF_SKYRIDE) {
                    throw new GeneratorException("For the Skyride, tree model/tree prior combination not implemented by BEAST." + "\nThe Skyride is only available for a single tree model partition in this release.", BeautiFrame.TREES);
                }
            }
        }
        //+++++++++++++++ Starting tree ++++++++++++++++
        for (PartitionTreeModel model : options.getPartitionTreeModels()) {
            if (model.getStartingTreeType() == StartingTreeType.USER) {
                if (model.getUserStartingTree() == null) {
                    throw new GeneratorException("Please select a starting tree in " + BeautiFrame.TREES + " panel, " + "\nwhen choosing user specified starting tree option.", BeautiFrame.TREES);
                }
            }
        }
        //++++++++++++++++ Random local clock model validation ++++++++++++++++++
        for (PartitionClockModel model : options.getPartitionClockModels()) {
            // 1 random local clock CANNOT have different tree models
            if (model.getClockType() == ClockType.RANDOM_LOCAL_CLOCK) {
                // || AUTOCORRELATED_LOGNORMAL
                PartitionTreeModel treeModel = null;
                for (AbstractPartitionData pd : options.getDataPartitions(model)) {
                    // only the PDs linked to this tree model
                    if (treeModel != null && treeModel != pd.getPartitionTreeModel()) {
                        throw new GeneratorException("A single random local clock cannot be applied to multiple trees.", BeautiFrame.CLOCK_MODELS);
                    }
                    treeModel = pd.getPartitionTreeModel();
                }
            }
        }
        //++++++++++++++++ Tree Model ++++++++++++++++++
        for (PartitionTreeModel model : options.getPartitionTreeModels()) {
            int numOfTaxa = -1;
            for (AbstractPartitionData pd : options.getDataPartitions(model)) {
                if (pd.getTaxonCount() > 0) {
                    if (numOfTaxa > 0) {
                        if (numOfTaxa != pd.getTaxonCount()) {
                            throw new GeneratorException("Partitions with different taxa cannot share the same tree.", BeautiFrame.DATA_PARTITIONS);
                        }
                    } else {
                        numOfTaxa = pd.getTaxonCount();
                    }
                }
            }
        }
        //++++++++++++++++ Prior Bounds ++++++++++++++++++
        for (Parameter param : options.selectParameters()) {
            if (param.getInitial() != Double.NaN) {
                if (param.isTruncated && (param.getInitial() < param.truncationLower || param.getInitial() > param.truncationUpper)) {
                    throw new GeneratorException("Parameter \"" + param.getName() + "\":" + "\ninitial value " + param.getInitial() + " is NOT in the range [" + param.truncationLower + ", " + param.truncationUpper + "]," + "\nor this range is wrong. Please check the Prior panel.", BeautiFrame.PRIORS);
                } else if (param.priorType == PriorType.UNIFORM_PRIOR && (param.getInitial() < param.uniformLower || param.getInitial() > param.uniformUpper)) {
                    throw new GeneratorException("Parameter \"" + param.getName() + "\":" + "\ninitial value " + param.getInitial() + " is NOT in the range [" + param.uniformLower + ", " + param.uniformUpper + "]," + "\nor this range is wrong. Please check the Prior panel.", BeautiFrame.PRIORS);
                }
                if (param.isNonNegative && param.getInitial() < 0.0) {
                    throw new GeneratorException("Parameter \"" + param.getName() + "\":" + "\ninitial value " + param.getInitial() + " should be non-negative. Please check the Prior panel.", BeautiFrame.PRIORS);
                }
                if (param.isZeroOne && (param.getInitial() < 0.0 || param.getInitial() > 1.0)) {
                    throw new GeneratorException("Parameter \"" + param.getName() + "\":" + "\ninitial value " + param.getInitial() + " should lie in the interval [0, 1]. Please check the Prior panel.", BeautiFrame.PRIORS);
                }
            }
        }
        checkComponentOptions();
    // add other tests and warnings here
    // Speciation model with dated tips
    // Sampling rates without dated tips or priors on rate or nodes
    } catch (Exception e) {
        // catch any other exceptions here and rethrow to generate messages
        throw new GeneratorException(e.getMessage());
    }
}

Example 44 with TaxonList

use of dr.evolution.util.TaxonList in project beast-mcmc by beast-dev.

the class DataModelImporter method importBEASTFile.

// xml
private void importBEASTFile(File file, DateGuesser guesser, Map dataModel) throws IOException, ImportException {
    try {
        FileReader reader = new FileReader(file);
        BeastImporter importer = new BeastImporter(reader);
        List<TaxonList> taxonLists = new ArrayList<TaxonList>();
        List<Alignment> alignments = new ArrayList<Alignment>();
        importer.importBEAST(taxonLists, alignments);
        TaxonList taxa = taxonLists.get(0);
        int count = 1;
        for (Alignment alignment : alignments) {
            String name = file.getName();
            if (alignment.getId() != null && alignment.getId().length() > 0) {
                name = alignment.getId();
            } else {
                if (alignments.size() > 1) {
                    name += count;
                }
            }
            setData(dataModel, guesser, name, taxa, taxonLists, alignment, null, null, null);
            count++;
        }
        reader.close();
    } catch (JDOMException e) {
        throw new ImportException(e.getMessage());
    } catch (ImportException e) {
        throw new ImportException(e.getMessage());
    } catch (IOException e) {
        throw new IOException(e.getMessage());
    }
}

Example 45 with TaxonList

use of dr.evolution.util.TaxonList in project beast-mcmc by beast-dev.

the class TreeMetrics method analyze.

/**
	 * Analyze trace
	 * @param trees an array of trees
	 * @param update the step size between instances of tree
	 */
private static void analyze(Tree[] trees, int update) {
    TaxonList masterList = trees[0];
    System.out.println("Calculating splits...");
    SplitSystem[] splits = new SplitSystem[trees.length];
    for (int i = 0; i < splits.length; i++) {
        splits[i] = SplitUtils.getSplits(masterList, trees[i]);
    }
    int maxOffset = MAX_OFFSET;
    int samples = trees.length;
    if ((samples / 3) < maxOffset) {
        maxOffset = (samples / 3);
    }
    double[] meanDistances = new double[maxOffset];
    System.out.println("Calculating mean distance per lag...");
    for (int i = 0; i < maxOffset; i++) {
        meanDistances[i] = 0;
        for (int j = 0; j < samples - i; j++) {
            double distance = getRobinsonFouldsRescaledDistance(splits[i], trees[j]);
            meanDistances[i] += distance;
        }
        meanDistances[i] /= ((double) samples - i);
        System.out.println(meanDistances[i]);
    }
}