/*
* GeneralSubstitutionModelParser.java
*
* Copyright (c) 2002-2015 Alexei Drummond, Andrew Rambaut and Marc Suchard
*
* This file is part of BEAST.
* See the NOTICE file distributed with this work for additional
* information regarding copyright ownership and licensing.
*
* BEAST is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* BEAST is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with BEAST; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
package dr.oldevomodelxml.substmodel;
import dr.evolution.datatype.DataType;
import dr.oldevomodel.substmodel.FrequencyModel;
import dr.oldevomodel.substmodel.GeneralSubstitutionModel;
import dr.oldevomodel.substmodel.SVSComplexSubstitutionModel;
import dr.oldevomodel.substmodel.SVSGeneralSubstitutionModel;
import dr.evoxml.util.DataTypeUtils;
import dr.inference.model.BayesianStochasticSearchVariableSelection;
import dr.inference.model.Parameter;
import dr.xml.*;
import java.util.logging.Logger;
/**
* Parses a GeneralSubstitutionModel or one of its more specific descendants.
*/
public class GeneralSubstitutionModelParser extends AbstractXMLObjectParser {
public static final String GENERAL_SUBSTITUTION_MODEL = "generalSubstitutionModel";
public static final String DATA_TYPE = "dataType";
public static final String RATES = "rates";
public static final String RELATIVE_TO = "relativeTo";
public static final String FREQUENCIES = "frequencies";
public static final String INDICATOR = "rateIndicator";
public static final String SVS_GENERAL_SUBSTITUTION_MODEL = "svsGeneralSubstitutionModel";
public static final String SVS_COMPLEX_SUBSTITUTION_MODEL = "svsComplexSubstitutionModel";
public String getParserName() {
return GENERAL_SUBSTITUTION_MODEL;
}
public String[] getParserNames() {
return new String[]{getParserName(), SVS_GENERAL_SUBSTITUTION_MODEL, SVS_COMPLEX_SUBSTITUTION_MODEL};
}
public Object parseXMLObject(XMLObject xo) throws XMLParseException {
Parameter ratesParameter = null;
FrequencyModel freqModel = null;
if (xo.hasChildNamed(FREQUENCIES)) {
XMLObject cxo = xo.getChild(FREQUENCIES);
freqModel = (FrequencyModel) cxo.getChild(FrequencyModel.class);
}
DataType dataType = DataTypeUtils.getDataType(xo);
if (dataType == null) dataType = (DataType) xo.getChild(DataType.class);
// if (xo.hasAttribute(DataType.DATA_TYPE)) {
// String dataTypeStr = xo.getStringAttribute(DataType.DATA_TYPE);
// if (dataTypeStr.equals(Nucleotides.DESCRIPTION)) {
// dataType = Nucleotides.INSTANCE;
// } else if (dataTypeStr.equals(AminoAcids.DESCRIPTION)) {
// dataType = AminoAcids.INSTANCE;
// } else if (dataTypeStr.equals(Codons.DESCRIPTION)) {
// dataType = Codons.UNIVERSAL;
// } else if (dataTypeStr.equals(TwoStates.DESCRIPTION)) {
// dataType = TwoStates.INSTANCE;
// }
// }
if (dataType == null) dataType = freqModel.getDataType();
if (dataType != freqModel.getDataType()) {
throw new XMLParseException("Data type of " + getParserName() + " element does not match that of its frequencyModel.");
}
XMLObject cxo = xo.getChild(RATES);
ratesParameter = (Parameter) cxo.getChild(Parameter.class);
int states = dataType.getStateCount();
Logger.getLogger("dr.evomodel").info(" General Substitution Model (stateCount=" + states + ")");
boolean hasRelativeRates = cxo.hasChildNamed(RELATIVE_TO) || (cxo.hasAttribute(RELATIVE_TO) && cxo.getIntegerAttribute(RELATIVE_TO) > 0);
int nonReversibleRateCount = ((dataType.getStateCount() - 1) * dataType.getStateCount());
int reversibleRateCount = (nonReversibleRateCount / 2);
boolean isNonReversible = ratesParameter.getDimension() == nonReversibleRateCount;
boolean hasIndicator = xo.hasChildNamed(INDICATOR);
if (!hasRelativeRates) {
Parameter indicatorParameter = null;
if (ratesParameter.getDimension() != reversibleRateCount && ratesParameter.getDimension() != nonReversibleRateCount) {
throw new XMLParseException("Rates parameter in " + getParserName() + " element should have " + (reversibleRateCount)
+ " dimensions for reversible model or " + nonReversibleRateCount + " dimensions for non-reversible. " +
"However parameter dimension is " + ratesParameter.getDimension());
}
if (hasIndicator) { // this is using BSSVS
cxo = xo.getChild(INDICATOR);
indicatorParameter = (Parameter) cxo.getChild(Parameter.class);
if (indicatorParameter.getDimension() != ratesParameter.getDimension()) {
throw new XMLParseException("Rates and indicator parameters in " + getParserName() + " element must be the same dimension.");
}
boolean randomize = xo.getAttribute(ComplexSubstitutionModelParser.RANDOMIZE, false);
if (randomize) {
BayesianStochasticSearchVariableSelection.Utils.randomize(indicatorParameter,
dataType.getStateCount(), !isNonReversible);
}
}
if (isNonReversible) {
Logger.getLogger("dr.evomodel").info(" Using BSSVS Complex Substitution Model");
return new SVSComplexSubstitutionModel(getParserName(), dataType, freqModel, ratesParameter, indicatorParameter);
} else {
Logger.getLogger("dr.evomodel").info(" Using BSSVS General Substitution Model");
return new SVSGeneralSubstitutionModel(dataType, freqModel, ratesParameter, indicatorParameter);
}
} else {
// if we have relativeTo attribute then we use the old GeneralSubstitutionModel
if (ratesParameter.getDimension() != reversibleRateCount - 1) {
throw new XMLParseException("Rates parameter in " + getParserName() + " element should have " + (reversibleRateCount - 1)
+ " dimensions. However parameter dimension is " + ratesParameter.getDimension());
}
int relativeTo = 0;
if (hasRelativeRates) {
relativeTo = cxo.getIntegerAttribute(RELATIVE_TO) - 1;
}
if (relativeTo < 0 || relativeTo >= reversibleRateCount) {
throw new XMLParseException(RELATIVE_TO + " must be 1 or greater");
} else {
int t = relativeTo;
int s = states - 1;
int row = 0;
while (t >= s) {
t -= s;
s -= 1;
row += 1;
}
int col = t + row + 1;
Logger.getLogger("dr.evomodel").info(" Rates relative to "
+ dataType.getCode(row) + "<->" + dataType.getCode(col));
}
if (ratesParameter == null) {
if (reversibleRateCount == 1) {
// simplest model for binary traits...
} else {
throw new XMLParseException("No rates parameter found in " + getParserName());
}
}
return new GeneralSubstitutionModel(dataType, freqModel, ratesParameter, relativeTo);
}
}
//************************************************************************
// AbstractXMLObjectParser implementation
//************************************************************************
public String getParserDescription() {
return "A general reversible model of sequence substitution for any data type.";
}
public Class getReturnType() {
return GeneralSubstitutionModelParser.class;
}
public XMLSyntaxRule[] getSyntaxRules() {
return rules;
}
private final XMLSyntaxRule[] rules = {
new XORRule(
new StringAttributeRule(DataType.DATA_TYPE, "The type of sequence data",
DataType.getRegisteredDataTypeNames(), false),
new ElementRule(DataType.class)
, true),
new ElementRule(FREQUENCIES, FrequencyModel.class),
new ElementRule(RATES,
new XMLSyntaxRule[]{
new ElementRule(Parameter.class)}
),
new ElementRule(INDICATOR,
new XMLSyntaxRule[]{
new ElementRule(Parameter.class),
}, true),
AttributeRule.newBooleanRule(ComplexSubstitutionModelParser.RANDOMIZE, true),
};
}