Java NexusImporter类代码示例

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public static void simulate(String inputFileName, String treesFileName, String outputFileName) throws IOException, TraceException, Importer.ImportException {
        File logFile = new File(inputFileName);

        System.out.println("Loading trace file: " + inputFileName);
        LogFileTraces traces = new LogFileTraces(inputFileName, logFile);
        traces.loadTraces();
        traces.setBurnIn(0);
        System.out.println(traces.getStateCount() + " states loaded");

        System.out.println();
        System.out.println("Opening trees file: " + treesFileName);
//        BufferedReader reader = new BufferedReader(new FileReader(treesFileName));

        System.out.println("Simulating...");
        System.out.println("0              25             50             75            100");
        System.out.println("|--------------|--------------|--------------|--------------|");

        int stepSize = traces.getStateCount() / 60;
        if (stepSize < 1) stepSize = 1;

        PrintWriter writer = new PrintWriter(new FileWriter(outputFileName));

        FileReader fileReader = new FileReader(treesFileName);
        TreeImporter importer = new NexusImporter(fileReader);

            EmpiricalDemographicFunction demo = null;
            IntervalGenerator intervals = null;
            TreeSimulator sim = null;

            CoalGenData data = new CoalGenData();
            data.traces = traces;
            data.setDemographicModel(7); // const stepwise bsp
            data.setupSkyline();

            double[] popSizes = new double[data.popSizeCount];
            double[] groupSizes = new double[data.groupSizeCount];


            NewickExporter exporter = new NewickExporter(writer);
            int count = 0;
            try {
                while (importer.hasTree()) {
                    RootedTree inTree = (RootedTree)importer.importNextTree();

                    if (sim == null) {
                        setSamplingTimes(inTree);
                        sim = new TreeSimulator(inTree.getTaxa(), "date");
                    }

                    data.getNextSkyline(popSizes, groupSizes);

                    double[] times = getTimes(inTree, groupSizes);
                    demo = new EmpiricalDemographicFunction(popSizes, times, true);
                    intervals = new CoalescentIntervalGenerator(demo);

                    RootedTree outTree = sim.simulate(intervals);

                    exporter.exportTree(outTree);
                    writer.println();
                    writer.flush();

                    if (count > 0 && count % stepSize == 0) {
                        System.out.print("*");
                        System.out.flush();
                    }
                    count++;
                }
            } catch (ImportException e) {
                e.printStackTrace();
            }

        fileReader.close();


        writer.close();

    }
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public TimeSlicerParser(String traitName, //
			NexusImporter treesImporter, //
			TimeParser timeParser, //
			int burnIn, //
			int assumedTrees, //
			
//			boolean hasRRWrate, //
			String rrwRateName, //
			
			double hpdLevel, //
			int gridSize, //
			double timescaleMultiplier, //
			Double[] sliceHeights //

	) {

		this.sliceHeights = sliceHeights;
		this.treesImporter = treesImporter;
		this.timeParser = timeParser;
		this.burnIn = burnIn;
		this.assumedTrees = assumedTrees;
		this.traitName = traitName;
		
//		this.hasRRWrate = hasRRWrate;
		this.rrwRateName = rrwRateName;
		this.hpdLevel = hpdLevel;

		this.gridSize = gridSize;
		this.timescaleMultiplier = timescaleMultiplier;

		this.uniqueAreaAttributes = new LinkedList<Attribute>();
		this.areasList = new LinkedList<Area>();
		
	}
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public final void doImport() {
        int returnVal = importChooser.showOpenDialog(this);
        if (returnVal == JFileChooser.APPROVE_OPTION) {
            File[] files = importChooser.getSelectedFiles();
            for (File file : files) {
                if (file == null || file.getName().equals("")) {
                    JOptionPane.showMessageDialog(this, "Invalid file name",
                            "Invalid file name", JOptionPane.ERROR_MESSAGE);
                } else {
                    try {
                        importDataFile(file);

                        setDirty();
//                    } catch (FileNotFoundException fnfe) {
//                        JOptionPane.showMessageDialog(this, "Unable to open file: File not found",
//                                "Unable to open file", JOptionPane.ERROR_MESSAGE);
                    } catch (IOException ioe) {
                        JOptionPane.showMessageDialog(this, "File I/O Error unable to read file: " + ioe.getMessage(),
                                "Unable to read file", JOptionPane.ERROR_MESSAGE);
                        return;

                    } catch (NexusImporter.MissingBlockException ex) {
                        JOptionPane.showMessageDialog(this, "TAXON, DATA or CHARACTERS block is missing in Nexus file: " + ex,
                                "Missing Block in Nexus File",
                                JOptionPane.ERROR_MESSAGE);

                    } catch (ImportException ime) {
                        JOptionPane.showMessageDialog(this, "Error parsing imported file: " + ime,
                                "Error reading file",
                                JOptionPane.ERROR_MESSAGE);
                        return;

//                    } catch (Exception ex) {
//                        JOptionPane.showMessageDialog(this, "Fatal exception: " + ex,
//                                "Error reading file",
//                                JOptionPane.ERROR_MESSAGE);
//                        return;
                    }
                }
            }

//            setAllOptions();
        }
    }
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
private TreeLineages loadTrees(InputFile inputFile) throws IOException {

        PrintStream progressStream = System.out;

        int totalTrees = 10000;
        int totalTreesUsed = 0;

        progressStream.println("Reading trees (bar assumes 10,000 trees)...");
        progressStream.println("0              25             50             75            100");
        progressStream.println("|--------------|--------------|--------------|--------------|");

        int stepSize = totalTrees / 60;
        if (stepSize < 1) stepSize = 1;

        TreeLineages treeLineages = new TreeLineages();

        FileReader fileReader = new FileReader(inputFile.getFile());
        jebl.evolution.io.NexusImporter importer = new NexusImporter(fileReader);
        try {
            totalTrees = 0;
            while (importer.hasTree()) {
                RootedTree tree = (RootedTree)importer.importNextTree();

                if (totalTrees >= inputFile.getBurnin()) {
                    treeLineages.addTree(tree);
                    totalTreesUsed += 1;
                }

                if (totalTrees > 0 && totalTrees % stepSize == 0) {
                    progressStream.print("*");
                    progressStream.flush();
                }
                totalTrees++;
            }

        } catch (ImportException e) {
            System.err.println("Error Parsing Input Tree: " + e.getMessage());
            return null;
        }
        fileReader.close();
        progressStream.println();
        progressStream.println();

        if (totalTrees < 1) {
            System.err.println("No trees");
            return null;
        }
        if (totalTreesUsed <= 1) {
            if (inputFile.getBurnin() > 0) {
                System.err.println("No trees to use: burnin too high");
                return null;
            }
        }

        progressStream.println("Total trees read: " + totalTrees);
        if (inputFile.getBurnin() > 0) {
            progressStream.println("Ignoring first " + inputFile.getBurnin() + " trees.");
        }

        treeLineages.setupTrees();

        return treeLineages;
    }
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public static RootedTree importRootedTree(String tree) throws IOException, ImportException {
	TreeImporter importer = new NexusImporter(new FileReader(tree));
	RootedTree rootedTree = (RootedTree) importer.importNextTree();

	return rootedTree;
}
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public static void simulate(String inputFileName, String treesFileName, String outputFileName) throws IOException, TraceException, Importer.ImportException {
    File logFile = new File(inputFileName);

    BufferedReader reader = new BufferedReader(new FileReader(logFile));

    System.out.println("Loading trace file: " + inputFileName);
    LogFileTraces traces = new LogFileTraces(inputFileName, logFile);
    traces.loadTraces(reader);
    traces.setBurnIn(0);
    System.out.println(traces.getStateCount() + " states loaded");

    System.out.println();
    System.out.println("Opening trees file: " + treesFileName);
    reader = new BufferedReader(new FileReader(treesFileName));

    System.out.println("Simulating...");
    System.out.println("0              25             50             75            100");
    System.out.println("|--------------|--------------|--------------|--------------|");

    int stepSize = traces.getStateCount() / 60;
    if (stepSize < 1) stepSize = 1;

    PrintWriter writer = new PrintWriter(new FileWriter(outputFileName));

    FileReader fileReader = new FileReader(treesFileName);
    TreeImporter importer = new NexusImporter(fileReader);

        EmpiricalDemographicFunction demo = null;
        IntervalGenerator intervals = null;
        TreeSimulator sim = null;

        CoalGenData data = new CoalGenData();
        data.traces = traces;
        data.setDemographicModel(7); // const stepwise bsp
        data.setupSkyline();

        double[] popSizes = new double[data.popSizeCount];
        double[] groupSizes = new double[data.groupSizeCount];


        NewickExporter exporter = new NewickExporter(writer);
        int count = 0;
        try {
            while (importer.hasTree()) {
                RootedTree inTree = (RootedTree)importer.importNextTree();

                if (sim == null) {
                    setSamplingTimes(inTree);
                    sim = new TreeSimulator(inTree.getTaxa(), "date");
                }

                data.getNextSkyline(popSizes, groupSizes);

                double[] times = getTimes(inTree, groupSizes);
                demo = new EmpiricalDemographicFunction(popSizes, times, true);
                intervals = new CoalescentIntervalGenerator(demo);

                RootedTree outTree = sim.simulate(intervals);

                exporter.exportTree(outTree);
                writer.println();
                writer.flush();

                if (count > 0 && count % stepSize == 0) {
                    System.out.print("*");
                    System.out.flush();
                }
                count++;
            }
        } catch (ImportException e) {
            e.printStackTrace();
        }

    fileReader.close();


    writer.close();

}
 

import jebl.evolution.io.NexusImporter; //导入依赖的package包/类
public static RootedTree importTree(String treeFilename) throws IOException, ImportException {
	
	NexusImporter importer = new NexusImporter(new FileReader(
			treeFilename));

	RootedTree rootedTree = (RootedTree) importer
			.importNextTree();
	
	return rootedTree;
}