Java Tree.IS_CLEAN属性代码示例

@Override
    public double calculateLogP() {
        if (beagle != null) {
            logP = beagle.calculateLogP();
            return logP;
        }
        final TreeInterface tree = treeInput.get();

        try {
        	if (traverse(tree.getRoot()) != Tree.IS_CLEAN)
        		calcLogP();
        }
        catch (ArithmeticException e) {
        	return Double.NEGATIVE_INFINITY;
        }
        m_nScale++;
        if (logP > 0 || (likelihoodCore.getUseScaling() && m_nScale > X)) {
//            System.err.println("Switch off scaling");
//            m_likelihoodCore.setUseScaling(1.0);
//            m_likelihoodCore.unstore();
//            m_nHasDirt = Tree.IS_FILTHY;
//            X *= 2;
//            traverse(tree.getRoot());
//            calcLogP();
//            return logP;
        } else if (logP == Double.NEGATIVE_INFINITY && m_fScale < 10 && !scaling.get().equals(Scaling.none)) { // && !m_likelihoodCore.getUseScaling()) {
            m_nScale = 0;
            m_fScale *= 1.01;
            Log.warning.println("Turning on scaling to prevent numeric instability " + m_fScale);
            likelihoodCore.setUseScaling(m_fScale);
            likelihoodCore.unstore();
            hasDirt = Tree.IS_FILTHY;
            traverse(tree.getRoot());
            calcLogP();
            return logP;
        }
        return logP;
    }
 

/**
 * check state for changed variables and update temp results if necessary *
 */
@Override
protected boolean requiresRecalculation() {
    if (beagle != null) {
        return beagle.requiresRecalculation();
    }
    hasDirt = Tree.IS_CLEAN;

    if (dataInput.get().isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        return true;
    }
    if (m_siteModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_DIRTY;
        return true;
    }
    if (branchRateModel != null && branchRateModel.isDirtyCalculation()) {
        //m_nHasDirt = Tree.IS_DIRTY;
        return true;
    }
    return treeInput.get().somethingIsDirty();
}
 

/**
 * check state for changed variables and update temp results if necessary *
 */
@Override
protected boolean requiresRecalculation() {
    if (beagle != null) {
        return beagle.requiresRecalculation();
    }
    hasDirt = Tree.IS_CLEAN;

    if (data.isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        return true;
    }
    if (m_siteModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_DIRTY;
        return true;
    }
    if (branchRateModel != null && branchRateModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_DIRTY;
        return true;
    }
    return tree.somethingIsDirty();
}
 

@Override
public boolean isDirtyBranch(Node speciesNode) {
    if (needsUpdate) {
        final RealParameter tipPopSizes = tipPopSizesInput.get();
        final RealParameter topPopSizes = topPopSizesInput.get();

        Arrays.fill(speciesBranchStatus, false);
        Node[] speciesNodes = speciesTree.getNodesAsArray();

        // non-root nodes (linear population sizes)
        for (int nodeI = 0; nodeI < speciesNodes.length; nodeI++) {
            // if the "top" population is dirty, no need to check the tip
            if (nodeI < rootNodeNumber && topPopSizes.isDirty(nodeI)) { // not the root node
                speciesBranchStatus[nodeI] = true;
                continue;
            }

            if (nodeI < leafNodeCount) { // is a leaf node
                speciesBranchStatus[nodeI] = tipPopSizes.isDirty(nodeI);
            } else { // is an internal node
                final Node leftChild = speciesNodes[nodeI].getLeft();
                final Node rightChild = speciesNodes[nodeI].getRight();
                final int leftChildTopI = leftChild.getNr();
                final int rightChildTopI = rightChild.getNr();
                speciesBranchStatus[nodeI] = topPopSizes.isDirty(leftChildTopI) ||
                        topPopSizes.isDirty(rightChildTopI) ||
                        leftChild.isDirty() != Tree.IS_CLEAN ||
                        rightChild.isDirty() != Tree.IS_CLEAN;
            }
        }

        //Arrays.fill(speciesBranchStatus, true);
        needsUpdate = false;
    }

    return speciesBranchStatus[speciesNode.getNr()];
}
 

/**
 * check state for changed variables and update temp results if necessary *
 */
@Override
protected boolean requiresRecalculation() {
    //System.err.println("flag1");
	/*if (m_beagle != null) {
		return m_beagle.requiresRecalculation();
	} */
    hasDirt = Tree.IS_CLEAN;

    if(weightsChanged){
        hasDirt = -1;
        //System.err.println("flag2");
        return true;            
    }

    if (branchRateModel != null && branchRateModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        //System.err.println("flag3");
        return true;
    }

    if (dataInput.get().isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        //System.err.println("flag4");
        return true;
    }

    if (m_siteModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_DIRTY;
        //System.err.println("flag5");
        return true;
    }

    return treeInput.get().somethingIsDirty();
}
 

/**
 * check state for changed variables and update temp results if necessary *
 */
@Override
protected boolean requiresRecalculation() {
    hasDirt = Tree.IS_CLEAN;
    
    double[] categoryRates = m_siteModel.getCategoryRates(null);
    if (constantPattern != null) {
        double [] tmp = new double [categoryRates.length - 1];
        for (int k = 0; k < invariantCategory; k++) {
        	tmp[k] = categoryRates[k];
        }
        for (int k = invariantCategory + 1; k < categoryRates.length; k++) {
        	tmp[k-1] = categoryRates[k];
        }
        categoryRates = tmp;
    }
    for (int i = 0; i < categoryRates.length; i++) {
    	if (categoryRates[i] != currentCategoryRates[i]) {
    		updateSiteModel = true;
    		break;
    	}
    }
    //updateSiteModel |= m_siteModel.isDirtyCalculation();

    if (substitutionModel instanceof CalculationNode) {
    	updateSubstitutionModel |= ((CalculationNode) substitutionModel).isDirtyCalculation();
    }
    
    if (dataInput.get().isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        return true;
    }
    if (m_siteModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_DIRTY;
        return true;
    }
    if (branchRateModel != null && branchRateModel.isDirtyCalculation()) {
        //m_nHasDirt = Tree.IS_FILTHY;
        return true;
    }

    return treeInput.get().somethingIsDirty();
}
 

/**
 * check state for changed variables and update temp results if necessary *
 */
@Override
protected boolean requiresRecalculation() {
    //printThings();

    hasDirt = Tree.IS_CLEAN;

    if(weightsChanged){

        if(addedPatternIdCount > 0){
            hasDirt = Tree.IS_FILTHY;
        }else{
            hasDirt = -1;
        }

        if (m_siteModel.isDirtyCalculation()) {
             hasDirt = Tree.IS_DIRTY;
            valueChanged = true;
        }
        //System.out.println("flag2");
        return true;
    }

    if (branchRateModel != null && branchRateModel.isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        //System.out.println("flag3");
        return true;
    }

    if (data.isDirtyCalculation()) {
        hasDirt = Tree.IS_FILTHY;
        //System.out.println("flag4");
        return true;
    }

    if (m_siteModel.isDirtyCalculation()) {
        valueChanged = true;
        hasDirt = Tree.IS_DIRTY;
        //System.out.println("flag5");
        return true;
    }

    return tree.somethingIsDirty();
}