├── images
    └── PATE.png
├── template.sh
├── helperScripts
    ├── getPloidy.pl
    ├── estimatePloidy.pl
    ├── getAB.pl
    └── PATE_formatInput.pl
├── LICENSE
├── ploidy.txt
├── PATE.ctl
├── README.md
└── PATE.pl


/images/PATE.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gtiley/Phasing/HEAD/images/PATE.png


--------------------------------------------------------------------------------
/template.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #SBATCH --job-name=__RUNID__
 3 | #SBATCH --output=__LOGFILE__
 4 | #SBATCH --mail-user=__YOUR_EMAIL__
 5 | #SBATCH --mail-type=FAIL
 6 | #SBATCH --time=24:00:00
 7 | #SBATCH --mem-per-cpu=16000M
 8 | #SBATCH --nodes=1
 9 | #SBATCH --ntasks=1
10 | #SBATCH --cpus-per-task=1
11 | #SBATCH --qos=__YOUR_QUEUE__
12 | #SBATCH --account=__YOUR_ACCOUNT__
13 | 
14 | module load picard/2.9.2
15 | module load bwa/0.7.17
16 | module load gatk/4.1.4.0
17 | module load samtools/1.10
18 | module load bamtools/2.1.1
19 | modele load R
20 | 


--------------------------------------------------------------------------------
/helperScripts/getPloidy.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | use strict;
 3 | 
 4 | my $phasingRoot = $ARGV[0];
 5 | my $ploidyFile = $ARGV[1];
 6 | my $estimatedPloidyPath = $ARGV[2];
 7 | 
 8 | my %ploidies = ();
 9 | 
10 | open FH1,'<',"$phasingRoot/$ploidyFile";
11 | while(<FH1>)
12 | {
13 | 	if (/^(\S+)\s+(\d+)\s+.*/)
14 | 	{
15 | 		my $tax = $1;
16 | 		my $startPloidy = $2;
17 | 		if ($startPloidy != 2)
18 | 		{
19 | 			print "Warning - starting ploidy for estimation was not 2 ($tax = $startPloidy) and results may be flawed\n";
20 | 		}
21 | 		$ploidies{$tax} = $startPloidy;
22 | 		open FH2,'<',"$estimatedPloidyPath/$tax/$tax.modelSelection.txt";
23 | 		while(<FH2>)
24 | 		{
25 | 			if (/Ploidy\:\s+(\d+)/)
26 | 			{
27 | 				my $estimatedPloidy = $1;
28 | 				$ploidies{$tax} = $estimatedPloidy;
29 | 			}
30 | 		}
31 | 		close FH2;
32 | 	}
33 | }
34 | close FH1;
35 | 
36 | open OUT1,'>',"$phasingRoot/$ploidyFile.estimated";
37 | foreach my $tax (keys %ploidies)
38 | {
39 | 	print OUT1 "$tax\t$ploidies{$tax}\n"
40 | }
41 | close OUT1;


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 George P. Tiley
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/helperScripts/estimatePloidy.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | 
 3 | $scheduler = $ARGV[0];
 4 | $template = $ARGV[1];
 5 | $ploidypath = $ARGV[2];
 6 | $helperpath = $ARGV[3];
 7 | $tax = $ARGV[4];
 8 | 
 9 | $scheduler =~ s/scheduler\_//;
10 | 
11 | open OUT1,'>',"$ploidypath/$tax/$tax.mixturemodels.sh";
12 | open FH1,'<',"$template";
13 | while(<FH1>)
14 | {
15 | my $line = $_;
16 | chomp $line;
17 | $line =~ s/__RUNID__/$tax.mixturemodels.id/;
18 | $line =~ s/__LOGFILE__/$tax.mixturemodels.log/;
19 | print OUT1 "$line\n";
20 | }
21 | close FH1;
22 | print OUT1 "$ploidypath/$tax\n";
23 | open OUT2,'>',"$ploidypath/$tax/getPloidy.R";
24 | print OUT2 "setwd(\"$ploidypath/$tax\");\n";
25 | print OUT2 "source(\"$helperpath/Ks_plots/ploidy.test.R\")\;\nsource(\"$helperpath/Ks_plots/fitMixEM.R\")\;\nsource(\"$helperpath/Ks_plots/plotComponentExpectations.R\")\;\n";
26 | print OUT2 "dat <- read.table(\"$ploidypath/$tax/$tax.ab\",header=TRUE,sep=\"\\t\")\;\n";
27 | print OUT2 "ploidy.test(dat\$AB,maxPloidy=6,model=4,nstarts=100,outPrefix=\"$tax\")\;\n";
28 | print OUT2 "quit();\n";
29 | close OUT2;
30 | print OUT1 "R CMD BATCH $ploidypath/$tax/getPloidy.R\n";
31 | close OUT1;
32 | system "$scheduler $ploidypath/$tax/$tax.mixturemodels.sh";


--------------------------------------------------------------------------------
/ploidy.txt:
--------------------------------------------------------------------------------
 1 | UFG_393202_P004_WG01 4 Dryopteris celsa
 2 | UFG_393202_P004_WH01 4 Dryopteris celsa
 3 | UFG_393202_P077_WE12 4 Dryopteris celsa
 4 | UFG_393202_P004_WB01 2 Dryopteris goldiana
 5 | UFG_393202_P010_WG12 2 Dryopteris goldiana
 6 | UFG_393202_P010_WH12 2 Dryopteris ludoviciana
 7 | UFG_393202_P077_WA12 2 Dryopteris ludoviciana
 8 | UFG_393202_P004_WE01 2 Dryopteris intermedia
 9 | UFG_393202_P004_WF01 2 Dryopteris intermedia
10 | UFG_393202_P077_WE11 2 Dryopteris intermedia
11 | UFG_393202_P010_WD12 2 Dryopteris expansa
12 | UFG_393202_P077_WB12 2 Dryopteris expansa
13 | UFG_393202_P082_WD06 2 Dryopteris expansa
14 | UFG_393202_P004_WA01 4 Dryopteris campyloptera
15 | UFG_393202_P004_WD01 4 Dryopteris campyloptera
16 | UFG_393202_P082_WH06 4 Dryopteris campyloptera
17 | UFG_393202_P004_WC01 4 Dryopteris carthusiana
18 | UFG_393202_P010_WA12 4 Dryopteris carthusiana
19 | UFG_393202_P077_WB11 4 Dryopteris carthusiana
20 | UFG_393202_P010_WB12 6 Dryopteris clintoniana
21 | UFG_393202_P010_WC12 6 Dryopteris clintoniana
22 | UFG_393202_P047_WB12 6 Dryopteris clintoniana
23 | UFG_393202_P010_WE12 4 Dryopteris cristata
24 | UFG_393202_P010_WF12 4 Dryopteris cristata
25 | UFG_393202_P077_WC12 4 Dryopteris cristata
26 | UFG_393202_P050_WA01 2 Polystichum munitum
27 | UFG_393202_P050_WG01 2 Polystichum speciossisimum
28 | 


--------------------------------------------------------------------------------
/PATE.ctl:
--------------------------------------------------------------------------------
 1 | #input and output paths
 2 | PHASING_ROOT = __YOUR_PATH__/Phasing
 3 | REF = __YOUR_PATH__/referenceFasta
 4 | GENOTYPE_OUT = __YOUR_PATH__/genotypeOutput
 5 | PHASE_OUT = __YOUR_PATH__/phasedOutput
 6 | FASTA_OUT = __YOUR_PATH__/fastaOutput
 7 | IUPAC_OUT = __YOUR_PATH__/iupacOutput
 8 | SUMMARYSTATS_OUT = __YOUR_PATH__/summaryStatsOutput
 9 | ESTPLOIDY_OUT = __YOUR_PATH__/estimatedPloidy
10 | FQ = __YOUR_PATH__/fastqFiles
11 | PLOIDY = __YOUR_PATH__/ploidy.txt
12 | 
13 | 
14 | #paths to software or just the binaries if already in your path
15 | BWA = bwa 
16 | PICARD = picard
17 | GATK = gatk
18 | SAMTOOLS = samtools
19 | BAMTOOLS = bamtools
20 | BGZIP = bgzip
21 | TABIX = tabix
22 | HPOPG = YOUR_PATH/H-PoPG_2/H-PoPG/H-PoPGv0.2.0.jar
23 | SCHEDULER = sbatch
24 | 
25 | #Path to the root directory of the helperScripts folder in the PATE repo
26 | HELPERSCRIPTS = __YOUR_PATH__/Phasing/helperScripts
27 | 
28 | #gatk filter options
29 | GATK_FILTER_EXPRESSION = "QD < 2.0" "QD_lt2"
30 | GATK_FILTER_EXPRESSION = "FS > 60.0" "FS_gt60"
31 | GATK_FILTER_EXPRESSION = "MQ < 40.0" "MQ_lt40"
32 | GATK_FILTER_EXPRESSION = "ReadPosRankSum < -8.0" "ReadPosRankSum_ltm8"
33 | GATK_FILTER_EXPRESSION = "AF < 0.025" "AF_lt025"
34 | GATK_FILTER_EXPRESSION = "AF > 0.975" "AF_gt975"
35 | GATK_FILTER_EXPRESSION = "DP < 10" "DP_lt10"
36 | 
37 | #Name of reference individual that matches the header in the reference fasta file
38 | REFERENCEIND = KJM225
39 | 
40 | #Should only unique sequences be printed to the fasta files of all phased haplotype sequences (0 = no | 1 = yes)
41 | UNIQUE_ONLY = 1
42 | REMOVE_READ_DUPLICATES = 0
43 | OUTPUT_EXPECTED_DOSAGE = 0
44 | 


--------------------------------------------------------------------------------
/helperScripts/getAB.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/perl -w
 2 | use strict;
 3 | 
 4 | my $vcfFile = $ARGV[0];
 5 | my $outFileRoot = $ARGV[1];
 6 | my %ABdata = ();
 7 | my %nvariants = ();
 8 | my %chromosomes  = ();
 9 | my %positions = ();
10 | my @taxa = ();
11 | my $ntax = 0;
12 | open FH1,'<',"$vcfFile";
13 | my $skippingHeader = 1;
14 | while (<FH1>)
15 | {
16 | 	my $line =$_;
17 | 	chomp $line;
18 | 	if ($line =~ m/^#CHROM/)
19 | 	{
20 | 	    my @temp = ();
21 | 	    @temp = split(/\s+/,$line);
22 | 	    for my $i (9..(scalar(@temp)-1))
23 | 	    {
24 | 		my @refPath = split(/\//,$temp[$i]);
25 | 		$taxa[$i] = $refPath[(scalar(@refPath)-2)];
26 | 		$nvariants{$taxa[$i]} = 0;
27 | 		$ntax++;
28 | 	    }
29 | 	    $skippingHeader = 0;
30 | 	}
31 | 	if ($skippingHeader == 0)
32 | 	{
33 | 		my @temp = ();
34 | 		@temp = split(/\s+/,$line);
35 | 		if ($temp[6] eq "PASS")
36 | 		{
37 | 			for my $i (9..(scalar(@temp)-1))
38 | 			{
39 | 			    my $filterValues = $temp[$i];
40 | 			    my @filterValuesVector = ();
41 | 			    @filterValuesVector = split(/\:/,$filterValues);
42 | 			    #print "@filterValuesVector\n";
43 | 			    if ($filterValuesVector[1] =~ m/(\d+)\,(\d+)/)
44 | 			    {
45 | 				my $refAllele = $1;
46 | 				my $altAllele = $2;
47 | 				if ((($refAllele + $altAllele) >= 10) && ($refAllele > 1) && ($altAllele > 1))
48 | 				{
49 | 				    my $abValue = $altAllele/($refAllele + $altAllele);
50 | 				    push @{$ABdata{$taxa[$i]}}, $abValue;
51 | 				    push @{$chromosomes{$taxa[$i]}}, $temp[0];
52 | 				    push @{$positions{$taxa[$i]}}, $temp[1];
53 | 				    $nvariants{$taxa[$i]} = $nvariants{$taxa[$i]} + 1;
54 | 				}
55 | 			    }
56 | 			}
57 | 		}
58 | 	}
59 | }
60 | close FH1;
61 | 
62 | for my $i (9..($ntax + 8))
63 | {
64 |     open OUT1,'>',"$outFileRoot/$taxa[$i]/$taxa[$i].ab";
65 |     print OUT1 "Chromosome\tPosition\tAB\n";
66 |     for my $j (0..($nvariants{$taxa[$i]} - 1))
67 |     {
68 | 	print OUT1 "$chromosomes{$taxa[$i]}[$j]\t$positions{$taxa[$i]}[$j]\t$ABdata{$taxa[$i]}[$j]\n";
69 |     }
70 |     close OUT1;
71 | }
72 | exit;
73 | 


--------------------------------------------------------------------------------
/helperScripts/PATE_formatInput.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | use strict;
  3 | 
  4 | #----------------------------------------------------------------------------------------#
  5 | #George P. Tiley and Andrew A. Crowl
  6 | #25 May 2021
  7 | #contact: george.tiley@duke.edu
  8 | #contact: andrew.crowl@duke.edu
  9 | #prepare reference sequences and reads for PATÉ
 10 | #----------------------------------------------------------------------------------------#
 11 | 
 12 | # Accepted AND necessary commands
 13 | my @checkArgs = ("filetype","inputFolder","outputFolder","ploidyFile");
 14 | my %passedArgs = ();
 15 | if (scalar(@ARGV) == 0)
 16 | {
 17 | die "/*--------INPUT PARAMETERS--------*/\n
 18 | --filetype STRING <fasta or fastq>
 19 | --inputFolder STRING <name of folder with input fasta or fastq files>
 20 | --outputFolder STRING <name of output folder of fasta or fastq files formatted for PATÉ>
 21 | --ploidyFile STRING <name of ploidy file>
 22 | 
 23 | \n/*--------EXAMPLE COMMAND--------*/\n
 24 |     perl PATE_formatInput.pl --filetype fasta --inputFolder supercontigs --outputFolder referenceSequences --ploidyFile ploidy.txt\n
 25 |     perl PATE_formatInput.pl --filetype fastq --inputFolder readsWithLongNames --outputFolder rawReads --ploidyFile ploidy.txt\n
 26 | 
 27 | \n/*--------FLAG OPTIONS--------*/\n
 28 | --filetype
 29 | 	fasta = Supercontig output from hybpiper is expected as input
 30 | 	fastq = uses the ploidy.txt file to get individual names and decompress and rename fastq files as IND.R1.fq an IND.R2.fq
 31 | 	
 32 | \n/*--------NOTES--------*/\n
 33 | Meant to be a convient tool for users to go straight from hybpiper into PATÉ. Other pre-processing tools can be added upon request, but consult the example input for formatting if not using hybpiper supercontigs as reference sequences.\n";
 34 | }
 35 | elsif (scalar(@ARGV) > 0)
 36 | {
 37 |     for my $i (0..(scalar(@ARGV) - 1))
 38 |     {
 39 | 		if ($ARGV[$i] eq "--filetype")
 40 | 		{
 41 | 	    	$passedArgs{filetype} = $ARGV[$i+1];
 42 | 		}
 43 | 		if ($ARGV[$i] eq "--inputFolder")
 44 | 		{
 45 | 	    	$passedArgs{inputFolder} = $ARGV[$i+1];
 46 | 		}
 47 | 		if ($ARGV[$i] eq "--outputFolder")
 48 | 		{
 49 |         	$passedArgs{outputFolder} = $ARGV[$i+1];
 50 |         	system "mkdir $passedArgs{outputFolder}";
 51 | 		}
 52 | 		if ($ARGV[$i] eq "--ploidyFile")
 53 | 		{
 54 | 	    	$passedArgs{ploidyFile} = $ARGV[$i+1];
 55 | 		}
 56 | 	}
 57 | 	foreach my $arg (@checkArgs)
 58 | 	{
 59 | 		if (! exists $passedArgs{$arg})
 60 | 		{
 61 | 	    	die "/*--------MISSING PARAMETER--------*/\nMissing command line argument: $arg\n\n";
 62 | 		}
 63 | 	}
 64 | }
 65 | 
 66 | if ($passedArgs{filetype} eq "fasta")
 67 | {
 68 | 	my %locusList = ();
 69 | 	my %seqs = ();
 70 | 	my %taxList = ();
 71 | 	open FH1,'<',"$passedArgs{ploidyFile}";
 72 | 	while (<FH1>)
 73 | 	{
 74 | 		if (/^(\S+)\s+.+/)
 75 | 		{
 76 | 			my $tax = $1;
 77 | 			if (! exists $taxList{$tax})
 78 | 			{
 79 | 				$taxList{$tax} = 1;
 80 | 			}
 81 | 		}
 82 | 	}
 83 | 	close FH1;
 84 | 
 85 | 	my @ff1 = glob("$passedArgs{inputFolder}/*.fasta");
 86 | 	foreach my $ff (@ff1)
 87 | 	{
 88 |     	if ($ff =~ m/$passedArgs{inputFolder}\/(\S+)\.fasta/)
 89 |     	{
 90 |         	my $locus = $1;
 91 |         	my $tax = "";
 92 | 	        if (! exists $locusList{$locus})
 93 |     	    {
 94 |         	    $locusList{$locus} = 1;
 95 |         	}
 96 |        		open FH1,'<',"$ff";
 97 | 	        while (<FH1>)
 98 |     	    {                                                                                                         
 99 |             	if (/^>(\S+)/)
100 |             	{
101 |                 	$tax = $1;
102 | 					foreach my $ind (sort keys %taxList)
103 | 					{
104 | 						if (index($tax,$ind) >= 0)
105 | 						{
106 | 							$tax = $ind;
107 | 						}
108 | 					}
109 |                 	$seqs{$locus}{$tax} = "";
110 |             	}
111 | 	            elsif (/(\S+)/)
112 |     	        {
113 |         	        my $seq = $1;
114 |             	    $seqs{$locus}{$tax} = $seqs{$locus}{$tax} . $seq;
115 |             	}
116 |         	}
117 | 	        close FH1;
118 |     	}
119 | 	}
120 | 
121 | 	foreach my $locus (sort keys %locusList)
122 | 	{
123 |     	open OUT1,'>',"$passedArgs{outputFolder}/$locus.fasta";
124 | 	    foreach my $tax (sort keys %taxList)
125 |     	{
126 |         	if (exists $seqs{$locus}{$tax})
127 | 	        {
128 |     	        print OUT1 ">$tax\n$seqs{$locus}{$tax}\n";
129 |         	}
130 |     	}
131 |     	close OUT1;
132 | 	}
133 | }
134 | 
135 | 
136 | if ($passedArgs{filetype} eq "fastq")
137 | {
138 | 	my %taxList = ();
139 | 	open FH1,'<',"$passedArgs{ploidyFile}";
140 | 	while (<FH1>)
141 | 	{
142 | 		if (/^(\S+)\s+.+/)
143 | 		{
144 | 			my $tax = $1;
145 | 			if (! exists $taxList{$tax})
146 | 			{
147 | 				$taxList{$tax} = 1;
148 | 			}
149 | 		}
150 | 	}
151 | 	close FH1;
152 | 	
153 | 	foreach my $tax (sort keys %taxList)
154 | 	{
155 | 		my @fqFiles = glob("$passedArgs{inputFolder}/*$tax*.*");
156 | 		foreach my $ff (@fqFiles)
157 | 		{
158 |     		if ($ff =~ m/$passedArgs{inputFolder}\/\S*R1\S*\.(\S+)/)
159 |     		{
160 | 	        	my $extension = $1;
161 | 	        	if ($extension =~ m/gz/)
162 | 	        	{
163 |     	    		system "cp $ff $passedArgs{outputFolder}/$tax.R1.fq.gz";
164 |     	    	}
165 |     	    	elsif ($extension =~ m/fq/ || $extension =~ m/fastq/)
166 | 	        	{
167 |     	    		system "cp $ff $passedArgs{outputFolder}/$tax.R1.fq";
168 |     	    	}
169 |     	    }
170 |     	    elsif ($ff =~ m/$passedArgs{inputFolder}\/\S*R2\S*\.(\S+)/)
171 |     		{
172 | 	        	my $extension = $1;
173 | 	        	if ($extension =~ m/gz/)
174 | 	        	{
175 |     	    		system "cp $ff $passedArgs{outputFolder}/$tax.R2.fq.gz";
176 |     	    	}
177 |     	    	elsif ($extension =~ m/fq/ || $extension =~ m/fastq/)
178 | 	        	{
179 |     	    		system "cp $ff $passedArgs{outputFolder}/$tax.R2.fq";
180 |     	    	}
181 |     	    }
182 |     	}
183 | 	}
184 | }
185 | exit;


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # What is Phased Alleles from Target Enrichment data (PATÉ)?
  2 | 
  3 | ![Generalized PATÉ Workflow](./images/PATE.png)
  4 | 
  5 | PATÉ is a pipeline for recovering phased haplotype sequences from short-read data. The phased sequences depend on user-provided hapltype consensus or reference sequences, which could come from many applications but some recommendations are provided in our publications (Tiley et al. 2021; Crowl et al. 2022; Tiley et al. 2023). PATÉ has two primary pipelines: **species** and **populations**. The details are provided further down, but here are general differnces.
  6 | * Species - Each individual is genotyped against its own haplotype consensus sequences. This is appropriate when analyzing multiple individuals of moderate to high sequence divergence where using a single reference would potentially lead to short-read alignment errors (e.g. species). This could be appropriate for most phylogenetic systematic studies.
  7 | * Populations - Each individual is genotyped against the same reference. This is appropriate when their are many individuals equidistant to the reference where there is low sequence divergence so as not to confound joint genotyping. This could be appropriate for the analysis of multiple populations of a single species or cases of incipient speciation. Within the **populations** pipeline is a way to estimate the ploidy level for each individual, but the authors remain skeptical about such tests (see details).
  8 | 
  9 | 
 10 | # Using the script
 11 | ## Try this to see options:
 12 | ```perl PATE.pl```
 13 | 
 14 | ## There are four input options and all are required
 15 | ```perl PATE.pl --controlFile PATE.ctl --runmode species --template template.sh --genotype consensus```
 16 | 1. The control file (PATE.ctl) is used to configure the paths to other software, your input data, and where you want your output.
 17 | 2. The runmode flag is used to determine if genotyping will be done jointly or not. There may be different conditions where one is desirable over the other. See below for more details.
 18 | 3. The template file (template.sh) has the basic directives you will use for running on a cluster. Or if running on your local computer, you can set environment variables at run time.
 19 | 4. The genotype flag determines how phasing ambiguity is handeled. See below for details.
 20 | 
 21 | ## Important Note - you will run the script twice
 22 | 1. First in --runmode ```species``` or ```population1```
 23 | 	+ ```species``` will run GATK *HaplotypeCaller* on each individual, that is realigning short reads to the consensus assemblies to get genotypes based on ploidy levels specified in the *ploidy file*.
 24 | 	+ ```population1``` will run GATK on each individual in gVCF mode and set up the script for joint genotyping based on the specified ploidy levels. You will have to submit the joint genotyping job separately after the gVCF files are generated. The reference individual is specified in the *control file*.
 25 | 2. Second in --runmode ```alleles``` or ```population2```
 26 | 	+ ```alleles``` generates the per-locus fasta output and summary statistics based on the individual genotype data. This step is fast and happens on a single processor. Here the genotype < ```consensus``` || ```iupac``` > option comes into effect.
 27 | 	+```population2``` is similar to *alleles* but will split the multisample VCF by individual to pass to *H-PoPG* to handle the phasing. The same genotype flags apply.
 28 | 	+ The genotype option affects how variants with ambiguous phases are handeled. When multiple haplotype blocks are recovered for a locus, we retain the phasing of the block with the most variants only. ```consensus``` causes the others to be replaced with "N" while ```iupac``` causes these unphased variants to be replaced with there IUPAC codes. There may be analyses where one option is more favorable than the other, so we make both possibilities available here.  
 29 | 
 30 | ## Important Note - you will to install a few software on your computer or cluster
 31 | Please cite and credit the authors of all of the important bits that are glued together here.
 32 | * BWA (Li et al. 2009a)
 33 | * The samtools/htslib library (Li et al. 2009b)
 34 | * GATK (McKenna at al. 2012)
 35 | * HPoPG (Xie et al. 2016)
 36 | 
 37 | ## Explanation of the control file options
 38 | ### There are several input and output folders and files to keep track of
 39 | * PHASING_ROOT = the root directory that you clone or download from github
 40 | * REF = input folder reference fasta files
 41 | * GENOTYPE\_OUT = output folder for genotyping files
 42 | * PHASE\_OUT = output folder for phased sequences, but split by individual
 43 | * FASTA\_OUT = output folder for fasta files you want to use
 44 | 	+ PHASED - these are the fasta files with all phased alleles per-locus
 45 | 	+ GENOTYPE - these fasta files have the unphased genotype sequences
 46 | 	+ PICKONE - these are the fasta files with only one haplotypic sequence available per individual per locus. These data may be preferred for phylogenetic network analyses.
 47 | * IUPAC\_OUT = output folder for phased sequences, but split by individual
 48 | * SUMMARYSTATS\_OUT = output folder with all of the phasing summary statistics
 49 | * ESTPLOIDY\_OUT = output folder with all genotyping and mixture model results along with a new ploidy file
 50 | * FQ = input folder of fastq files
 51 | * PLOIDY = input ploidy file (see below)
 52 | 
 53 | ### The software dependencies
 54 | * BWA = path to bwa
 55 | * PICARD = path to picard
 56 | * GATK = path to gatk
 57 | * SAMTOOLS = path to samtools
 58 | * BAMTOOLS = path to bamtools
 59 | * BGZIP = path to bgzip from htslib 
 60 | * TABIX = path to tabix from htslib
 61 | * HPOPG = path to H-PoPG jar file
 62 | * SCHEDULER = The submission command for your scheduler (SLURM uses sbatch)
 63 | 
 64 | ### We make the VCF filtering options for GATK an option that the user can change. Each line is a separate filter and has the specific formatting of "<FILTER>" <whitespace> "<FILTER NAME>"
 65 | ### The following are some reasonable defaults, but will note always be optimal. Consult VCF filtering annotations before altering.
 66 | * GATK\_FILTER\_EXPRESSION = "QD < 2.0" "QD\_lt2"
 67 | * GATK\_FILTER\_EXPRESSION = "FS > 60.0" "FS\_gt60"
 68 | * GATK\_FILTER\_EXPRESSION = "MQ < 40.0" "MQ\_lt40"
 69 | * GATK\_FILTER\_EXPRESSION = "ReadPosRankSum < -8.0" "ReadPosRankSum\_ltm8"
 70 | * GATK\_FILTER\_EXPRESSION = "AF < 0.05" "AF\_lt05"
 71 | * GATK\_FILTER\_EXPRESSION = "AF > 0.95" "AF\_gt95"
 72 | * GATK\_FILTER\_EXPRESSION = "DP < 10" "DP\_lt10"
 73 | 
 74 | ### Some additional options
 75 | * UNIQUE\_ONLY = <0 || 1> determines if only unique haplotypes are output following phasing by H-PoPG (0=no or 1=yes). It is very possible to have multiple identical haplotypes per locus.
 76 | * REMOVE\_READ\_DUPLICATES = <0 || 1> = should Picard be used to remove pcr duplicates. Leave at 0=no for all target enrichment studies but this can be turned on for non-enriched libraries.
 77 | * OUTPUT\_EXPECTED\_DOSAGE = <0 || 1> = should the expected number of sequences per individual be output even in the absence of variants. This might be needed when calculating allele frequencies.
 78 | 
 79 | To generate the output comparable to Tiley et al. (2021) or Crowl et al. (2022), use the following options:
 80 | * UNIQUE\_ONLY = 1
 81 | * REMOVE\_READ\_DUPLICATES = 0
 82 | * OUTPUT\_EXPECTED\_DOSAGE = 0
 83 | 
 84 | # Some notes on configuring data and folders
 85 | ## Naming of Fastq Files
 86 | Fastq files follow the following naming rules:
 87 | * Only paired-end data allowed
 88 | * Reads should be named as
 89 | 	+ &lt;Individual ID&gt;.R1.&lt;Fastq File Extension&gt;
 90 | 	+ &lt;Individual ID&gt;.R2.&lt;Fastq File Extention&gt;
 91 | 	+ where &lt;Individual ID&gt; = The individual name specified in the ploidy file
 92 | 	+ and &lt;Fastq File Extension&gt; = Whatever you want; It does not matter if named .fq, .fastq, .fq.gz, etc
 93 | * Fastq files are assumed to be pre-processed for quality and adapter removal. We do not integrate such tools here as some would argue that the soft-clipping in BWA is a better approach and GATK deals with quality explicitly.
 94 | * A helper script is available to format the fastq names for you, please see ```helperScripts/PATE_formatInput.pl```
 95 | 
 96 | ## The Ploidy File
 97 | This is where Individual IDs and their ploidy levels are specified. It has the following rules:
 98 | * At least two columns are present
 99 | * The first column is Individual ID
100 | * The second column is the ploidy level represented by an integer
101 | * More columns are allowed with any metadata you would like for your own purposes
102 | * Columns are seperated by whitespaces, do not format as comma-seperated
103 | 
104 | ## The Reference Fastas
105 | Reference fasta files have the following rules:
106 | * There is a sinlge fasta file per locus that contains reference sequences for all individuals
107 | * The reference fasta is named &lt;Locus Name&gt;.fasta
108 | 	+ No spaces allowed in locus name
109 | 	+ The locus name here will be the locus name of the output fasta with phased sequences
110 | * The fasta files are not interleaved and assume no line breaks in the sequence data
111 | * The fasta headers are assumed to match the Individual ID (i.e. &gt;&lt;Individual ID&gt;)
112 | * Other information can follow the Individual ID in the fasta header, but will be ignored
113 | * A helper script is available to format the fasta files for you, please see ```helperScripts/PATE_formatInput.pl```      
114 | 
115 | ## The Template File
116 | There is a file called template.sh to help distribute jobs on a cluster
117 | * Make the necessary changes to the scheuduler directives for your account
118 | * I was on a cluster with SLURM when making this - you will need to edit for PBS or SGE accordingly
119 | * If you run the script in runmode ```cluster```, all of the commands are pasted below what you have in the template.sh file - all you need to do is configure the directives and paths to software here if they are not specified in the control file
120 | * The template file must always be provided as an argument, even if using runmode ```serial``` or ```alleles```
121 | * The template file can be renamed if you like
122 | 
123 | ## Explanation of Summary Statistics
124 | An output after runmode=2 is ```averagePhasingStats.txt```, which contains a few numbers aggregated over all loci. Here is a description of each column.
125 | 1. INDIVIDUAL - individual ID
126 | 2. NLOCI - number of loci assembled by hybpiper
127 | 3. NVARLOCI - number of loci with at least 1 variant        
128 | 4. NINVLOCI - number of loci with no variants        
129 | 5. NPHASELOCI - number of loci phased (it is possible to have unphased loci with variants, in the case when there is 1 or more blocks with only 1 variant)      
130 | 6. AVG_LENGTH - average locus length      
131 | 7. AVG_NVAR - average number of variants (includes invariable loci - averaged across the total number of loci)        
132 | 8. AVG_HET - average heterozygosity (per-base heterozygosity averaged over all loci - including the invariable ones) 
133 | 9. AVG_NBLOCKS - average number of blocks per phased locus (thus, excluding loci without phasing information. Many of the Dryopteris individuals were close to 1 or even 1 in some cases. I think this is incredibly useful for evaluating how good the phasing is working.)
134 | 10. AVG_LONGESTBL - Average number of variants in the longest phasing block. (thus not including loci without phasing information) 
135 | 	+ 1 - number of loci that were completely homozygous       
136 | 	+ 2 - number of loci with two phased alleles	      
137 | 	+ 3       .
138 | 	+ 4       .
139 | 	+ 5       .
140 | 	+ 6 - number of loci with six phased alleles (six was the max in Dryopteris. If you have higher ploidies, this will automatically go higher because it is based off of the ploidy file. If you have octoploids for example, this will then go to 8)
141 | 
142 | # Some notes on ploidy estimation
143 | It is possible to estimate ploidy directly for the distributions of ratios with reads that carry the reference or alternate allele (Weiß et al. 2018; Viruel 2019). This is achieved by the --runmode ```estPloidy``` option and specifying an appropriate reference in the control file. All individuals are genotyped as a diploid and mixture models (Tiley et al. 2018) are used to determine the ploidy. I am skeptical that enough information is available in target enrichment data to achieve this task and an outgroup that can successfully polarize the alternate alleles are needed. Nevertheless, the option exists and may have value for some cases.
144 | 
145 | I have used the ploidy estimation feature for Tiley et al. (2023). The results did not seem unreasonable and mostly aligned with a prior analysis of the study system, but I still have reservations about model overfitting. I have recently generated ome RADseq data for the study system with some technical replicates of individuals with known ploidy. It might take time to evalutate results and fine-tune existing models, but I am happy to collaborate with others that have similar empirical test cases on the topic.
146 | 
147 | ## Using estPloidy
148 | Ploidy is dependent on some additional code for fitting the mixture models. Rather than repackage it here, it is available through another repo. Although cloning repos within repos is typically not recommened, it is the fastest way here. Make sure you are in the `helperScripts` directory first:
149 | ```
150 | cd Phasing/helperScripts
151 | git clone https://github.com/gtiley/Ks_plots
152 | ```
153 | # Opinions
154 | There are several technical issues compounded in the existing pipeline and I view this as a starting point for enabling some interesting analyses of polyploid complexes. 
155 | First, the genotyping problem in polyploids has a lot of uncertainty and I recommend reading Gerard et al. (2018) to better appreciate the problems. Comparisons of genotypers are needed in the future, but we do our best to filter out errors from the final set of variants.
156 | Second, there has apparently been a flurry of phasing algorithms developed for polyploids in the recent years after my colleagues and I began working on this pipeline and our ideas. I will try to investigate and compare some of them (e.g. Moeinzadeh et al. 2020) in the future.
157 | 
158 | # What happens when an entire locus is not phased?
159 | It is possible that two variants can be called in a locus but there is not sufficient read information, either due to quality or depth, to phase those variants with respect to the reference sequence. It can also depend on the library preparation. For example, if probes are designed across multiple exons of locus but the reads to not span the entire intron on some individuals. Who knows - it could also mean that the reference sequence is not appropriate, perhaps a chimera of homeologos sequences? In such cases regarless of the cause, we opt to retain the phased variants from the longest block while variants on the shorter block(s) are replaced by missing data (N). This is our least-worst strategy for keeping information while avoiding artificial recombination or generating loci of multiple ploidy levels (i.e. I do not think using the ambiguity codes here is a good idea). The number of loci where this happens from the target enrichment data I have evaluated is very low, but paying attention to the AVG_NBLOCKS summary statistic can help identify individuals with phasing difficulties.
160 | 
161 | # Active development - some features that are planned in the near future
162 | 1. Imputation
163 | 2. SFS estimation
164 | 3. Parent assignment
165 | 4. Determining allo vs. autopolyploidy
166 | 
167 | # References
168 | * Crowl AA, Fritsch PW, Tiley GP, Lynch NP, Ranney TG, Ashrafi H, Manos PS. 2022. A First Complete Phylogenomic Hypothesis for Diploid Blueberries (Vaccinium section Cyanococcus). American Journal of Botany. In press.
169 | * Li H, Durbin R. 2009a. Fast and accurate short read alignment with Burrows-Wheeler transform. Bioinformatics 25:1754-1760.
170 | * Li H, Handsaker B, Wysoker A, Fennell T, Ruan J, Homer N, Marth G, Abecasis G, Durbin R, 1000 Genome Project Data Processing Subgroup. 2009b. The sequence alignment/map format and SAMtools. Bioinformatics 25:2078-2079. 
171 | * McKenna A, Hanna M, Banks E, Sivachenko A, Cibulskis K, Kernytsky A, Garimella K, Altshuler D, Gabriel S, Daly M, et al. 2010. The Genome Analysis Toolkit: a MapReduce framework for analyzing next-generation DNA sequencing data. Genome Res 20:1297-1303.
172 | * Xie M, Wu Q, Wang J, Jiang T. 2016. H-PoP and H-PoPG: heuristic partitioning algorithms for single individual haplotyping of polyploids. Bioinformatics 32:3735-3744.
173 | * Gerard D, Ferrão LFV, Garcia AAF, Stephens M. 2018. Genotyping polyploids from messy sequencing data. Genetics 210:789-807.
174 | * Moeinzadeh M-H, Yang J, Muzychenko E, Gallone G, Heller D, Reinert K, Haas S, Vingron M. 2020. Ranbow: A fast and accurate method for polyploid haplotype reconstruction. PLoS Comp Biol. 16:e1007843.
175 | * Schrinner SD, Mari RS, Ebler J, Rautiainen M, Seillier L, Reimer JJ, Usadel B, Marschall T. 2020. Haplotype threading: an accurate polyploid phasing from long reads. Genome Biol. 21:252.
176 | * Tiley GP, Barker MS, Burleigh JG. 2018. Assessing the Performance of *Ks* Plots for Detecting Ancient Whole Genome Duplications. Genome Biology and Evolution 10:2882-2898.
177 | * Tiley GP, Crowl AA, Manos PS, Sessa EB, Solís-Lemus C, Yoder AD, Burleigh JG. 2021. Phasing alleles improves network inference with allopolyploids. bioRxiv doi: https://doi.org/10.1101/2021.05.04.442457
178 | * Tiley GP, Crowl AA, Almary TOM, Luke WRQ, Solofondranohatra CL, Besnard G, Lehmann CER, Yoder AD, Vorontsova MS. 2023. Genetic variation in *Loudetia simplex* supports the presence of ancient grasslands in Madagascar. bioRxiv doi: https://doi.org/10.1101/2023.04.07.536094
179 | * Viruel J, Conejero M, Hidalgo O, Pokorny L, Powell RF, Forest F, Kantar MB, Soto Gomez M, Graham SW, Gravendeel B, Wilkin P, Leitch IJ. 2019. A Target Capture-Based Method to Estimate Ploidy from Herbarium Specimens. Front. Plant Sci. 10:937.
180 | * Weiß CL, Pais M, Cano LM, Kamoun S, Burbano HA. 2018. nQuire: a statistical framework for ploidy estimation using next generation sequencing. BMC Bioinformatics 19:122.
181 | 


--------------------------------------------------------------------------------
/PATE.pl:
--------------------------------------------------------------------------------
   1 | #!/usr/bin/perl -w
   2 | use strict;
   3 | 
   4 | #----------------------------------------------------------------------------------------#
   5 | #30 August 2022
   6 | #contact regarding code details: George P. Tiley g.tiley@kew.org
   7 | #contact regarding empirical performance: Andy Crowl andrew.crowl@duke.edu
   8 | #Genotype target-enrichment loci of known ploidy
   9 | #Estimate ploidy from allele balance if unknown
  10 | #Phase haplotype sequences for each locus
  11 | #----------------------------------------------------------------------------------------#
  12 | 
  13 | # Accepted AND necessary commands
  14 | my @checkArgs = ("controlFile","runmode","template","genotype");
  15 | my %passedArgs = ();
  16 | if (scalar(@ARGV) == 0)
  17 | {
  18 | die "/*--------INPUT PARAMETERS--------*/\n
  19 | --controlFile STRING <control file>
  20 | --runmode STRING <species or alleles or estPloidy or population1 or population2>
  21 | --template STRING <template file for distributing on a cluster>
  22 | --genotype STRING <consensus or iupac>
  23 | 
  24 | \n/*--------EXAMPLE COMMAND--------*/\n
  25 |     perl PATE.pl --controlFile PATE.ctl --runmode species --template template.sh --genotype consensus\n
  26 | 
  27 | \n/*--------FLAG OPTIONS--------*/\n
  28 | --runmode
  29 | 	species = genotype each individual against its own de novo assemblies aas a reference with directives given in template.sh
  30 | 	alleles = use phasing information to make orthologous fasta files with haplotype sequences AFTER --runmode species
  31 | 	estPloidy = estimate the ploidy for each individual in the ploidy.txt file based on allele balance information when genotying them as diploids. This requires a specified reference.
  32 | 	population1 = use joint genotyping of all individuals defined in the ploidy.txt file against a single reference at their specified ploidy
  33 | 	population2 = phase loci for each individual based on output from joint genotyping. The population mode is broken into 2 steps as the amount of time needed for the joint genotyping is highly variable.
  34 | 	
  35 | --genotype
  36 | 	consensus = Use the original reference sequence for each sample for each locus when there are no variants to phase
  37 | 	iupac = Use genotyped sequence with IUPAC codes when there are variants, but cannot be phased
  38 | 	
  39 | \n/*--------NOTES--------*/\n
  40 | This scripts automates a lot of the genotyping and phasing process, but has to be ran twice.
  41 | The first time use --runmode species OR --runmode population. The second time you will use --runmode alleles to create the phased fasta files. If all individuals can be compared to single reference individual, it is possible to estimate the ploidys directly from the sequence data with --runmode estPloidy.
  42 | All steps assume a single processor is used or allocated. This takes about 30 minutes for a sample of >100x but <1000x coverage. If you want to change these options you may have to alter the appropriate lines relevant to BWA and GATK.
  43 | We have yet to explore effects of different hard filtering strategies through GATK, this might require fine-tuning for low (e.g. <=15x) or very high (>1000x) depth data. Some reasonable defaults (in my opinion GPT) are set in the control file.
  44 | 
  45 | \n/*--------Important note affecting output--------*/\n
  46 | The control file variable UNIQUE_ONLY is by default set to 0. This creates a scenario where the expected number of alleles are output for every locus for every individual. Thus, there could be identical haplotype sequences output. This can be important for some population genetic analyses. It will cause the number of alleles recovered in the stats files to always match the ploidy level though.\n
  47 | Because it can be difficult to know the difference between true homozygosity and false negatives from low read coverage ect, it is possible to only output the unique haplotype sequences. This might be more appropriate for various phylogenetic applications. To only output the unique haplotypes, simply set UNIQUE_ONLY = 1. We used it in earlier iterations of PATÉ but the needs changed with research interests. It did not seem fair to force a user into one scenario versus another, so it is optional.\n\n";
  48 | }
  49 | 
  50 | elsif (scalar(@ARGV) > 0)
  51 | {
  52 |     for my $i (0..(scalar(@ARGV) - 1))
  53 |     {
  54 | 		if ($ARGV[$i] eq "--controlFile")
  55 | 		{
  56 | 	    	$passedArgs{controlFile} = $ARGV[$i+1];
  57 | 		}
  58 | 		if ($ARGV[$i] eq "--runmode")
  59 | 		{
  60 | 	    	$passedArgs{runmode} = $ARGV[$i+1];
  61 | 	    	if (($passedArgs{runmode} ne "species") and ($passedArgs{runmode} ne "population1") and ($passedArgs{runmode} ne "population2") and ($passedArgs{runmode} ne "alleles") and ($passedArgs{runmode} ne "estPloidy"))
  62 | 	    	{
  63 | 	    		die ("ERROR\n\n$passedArgs{runmode} is not a valid runmode option\n\nstopping to fix error\n")
  64 | 	    	}
  65 | 		}
  66 | 		if ($ARGV[$i] eq "--template")
  67 | 		{
  68 |         	$passedArgs{template} = $ARGV[$i+1];
  69 | 		}
  70 | 		if ($ARGV[$i] eq "--genotype")
  71 |         {
  72 | 		    $passedArgs{genotype} = $ARGV[$i+1];
  73 | 		    if (($passedArgs{genotype} ne "consensus") and ($passedArgs{genotype} ne "iupac"))
  74 | 	    	{
  75 | 	    		die ("ERROR\n\n$passedArgs{runmode} is not a valid genotype option\n\nstopping to fix error\n")
  76 | 	    	}
  77 |         }
  78 | 	}
  79 | 	foreach my $arg (@checkArgs)
  80 | 	{
  81 | 		if (! exists $passedArgs{$arg})
  82 | 		{
  83 | 	    	die "/*--------MISSING PARAMETER--------*/\nMissing command line argument: $arg\n\nIf running serially, try --template 0\n\n";
  84 | 		}
  85 | 	}
  86 | }
  87 | 
  88 | my %controlArgs = ();
  89 | my %variantFilters = (); 
  90 | open FH1,'<',"$passedArgs{controlFile}";
  91 | while (<FH1>)
  92 | {
  93 | 	if (/PHASING_ROOT\s+\=\s+(\S+)/)
  94 |     {
  95 | 		$controlArgs{PHASING_ROOT} = $1;
  96 |     }
  97 |     if (/PLOIDY\s+\=\s+(\S+)/)
  98 |     {
  99 | 		$controlArgs{PLOIDY} = $1;
 100 |     }
 101 |     if (/FQ\s+\=\s+(\S+)/)
 102 |     {
 103 |         $controlArgs{FQ} = $1;
 104 |     }
 105 |     if (/GENOTYPE_OUT\s+\=\s+(\S+)/)
 106 |     {
 107 | 		$controlArgs{GENOTYPE_OUT} = $1;
 108 | 		if ($passedArgs{runmode} ne "alleles" && $passedArgs{runmode} ne "estPloidy" && $passedArgs{runmode} ne "population2")
 109 | 		{
 110 | 			system "mkdir $controlArgs{GENOTYPE_OUT}";
 111 | 		}
 112 |     }
 113 |     if (/PHASE_OUT\s+\=\s+(\S+)/)
 114 |     {
 115 | 		$controlArgs{PHASE_OUT} = $1;
 116 | 		if ($passedArgs{runmode} ne "alleles" && $passedArgs{runmode} ne "estPloidy" && $passedArgs{runmode} ne "population2")
 117 | 		{
 118 | 			system "mkdir $controlArgs{PHASE_OUT}";
 119 | 		}
 120 |     }
 121 |     if (/IUPAC_OUT\s+\=\s+(\S+)/)
 122 |     {
 123 | 		$controlArgs{IUPAC_OUT} = $1;
 124 | 		if ($passedArgs{runmode} ne "alleles" && $passedArgs{runmode} ne "estPloidy" && $passedArgs{runmode} ne "population2")
 125 | 		{
 126 | 			system "mkdir $controlArgs{IUPAC_OUT}";
 127 | 		}
 128 |     }
 129 |     if (/FASTA_OUT\s+\=\s+(\S+)/)
 130 |     {
 131 | 		$controlArgs{FASTA_OUT} = $1;
 132 | 		if ($passedArgs{runmode} eq "alleles")
 133 | 		{
 134 | 			system "mkdir $controlArgs{FASTA_OUT}";
 135 | 			system "mkdir $controlArgs{FASTA_OUT}/PHASED";
 136 | 			system "mkdir $controlArgs{FASTA_OUT}/GENOTYPE";
 137 | 			system "mkdir $controlArgs{FASTA_OUT}/PICKONE";
 138 | 		}
 139 |     }
 140 |     if (/SUMMARYSTATS_OUT\s+\=\s+(\S+)/)
 141 |     {
 142 | 		$controlArgs{SUMMARYSTATS_OUT} = $1;
 143 | 		if ($passedArgs{runmode} eq "alleles")
 144 | 		{
 145 | 			system "mkdir $controlArgs{SUMMARYSTATS_OUT}";
 146 | 		}
 147 |     }
 148 |     if (/ESTPLOIDY_OUT\s+\=\s+(\S+)/)
 149 |     {
 150 | 		$controlArgs{ESTPLOIDY_OUT} = $1;
 151 | 		if ($passedArgs{runmode} eq "estPloidy")
 152 | 		{
 153 | 			system "mkdir $controlArgs{ESTPLOIDY_OUT}";
 154 | 		}
 155 |     }
 156 |     if (/HELPERSCRIPTS\s+\=\s+(\S+)/)
 157 |     {
 158 | 	    $controlArgs{HELPERSCRIPTS} = $1;
 159 | 	}
 160 |     if (/REF\s+\=\s+(\S+)/)
 161 |     {
 162 |         $controlArgs{REF} = $1;
 163 |     }
 164 |     if (/PICARD\s+\=\s+(\S+)/)
 165 |     {
 166 |         $controlArgs{PICARD} = $1;
 167 |         if ($controlArgs{PICARD} =~ m/\S+\.jar/)
 168 |         {
 169 |         	$controlArgs{PICARD} = "java -jar $controlArgs{PICARD}";
 170 |         }	
 171 |     }
 172 |     if (/BWA\s+\=\s+(\S+)/)
 173 |     {
 174 |         $controlArgs{BWA} = $1;
 175 |     }
 176 |     if (/GATK\s+\=\s+(\S+)/)
 177 |     {
 178 |         $controlArgs{GATK} = $1;
 179 |     }
 180 |     if (/HPOPG\s+\=\s+(\S+)/)
 181 |     {
 182 |         $controlArgs{HPOPG} = $1;
 183 |     }
 184 |     if (/SAMTOOLS\s+\=\s+(\S+)/)
 185 |     {
 186 |         $controlArgs{SAMTOOLS} = $1;
 187 |     }
 188 |     if (/BCFTOOLS\s+\=\s+(\S+)/)
 189 |     {
 190 |         $controlArgs{BCFTOOLS} = $1;
 191 |     }
 192 |     if (/BAMTOOLS\s+\=\s+(\S+)/)
 193 |     {
 194 |         $controlArgs{BAMTOOLS} = $1;
 195 |     }
 196 |     if (/BGZIP\s+\=\s+(\S+)/)
 197 |     {
 198 |         $controlArgs{BGZIP} = $1;
 199 |     }
 200 |     if (/TABIX\s+\=\s+(\S+)/)
 201 |     {
 202 |         $controlArgs{TABIX} = $1;
 203 |     }
 204 |     if (/SCHEDULER\s+\=\s+(\S+)/)
 205 |     {
 206 |         $controlArgs{SCHEDULER} = $1;
 207 |     }
 208 |     if (/GATK_FILTER_EXPRESSION\s+=\s+\"(.+)\"\s+\"(.+)\"/)
 209 |     {
 210 |     	my $filter = $1;
 211 |     	my $filterName = $2;
 212 |         push @{$variantFilters{FILTER}}, $filter;
 213 |         push @{$variantFilters{FILTERNAME}}, $filterName;
 214 |     }
 215 |     if (/REFERENCEIND\s+\=\s+(\S+)/)
 216 |     {
 217 |         $controlArgs{REFERENCEIND} = $1;
 218 |     }
 219 |     if (/UNIQUE_ONLY\s+\=\s+(\S+)/)
 220 |     {
 221 | 		$controlArgs{UNIQUE_ONLY} = $1;
 222 |     }
 223 |     if (/REMOVE_READ_DUPLICATES\s+\=\s+(\S+)/)
 224 |     {
 225 | 		$controlArgs{REMOVE_READ_DUPLICATES} = $1;
 226 |     }
 227 |     if (/OUTPUT_EXPECTED_DOSAGE\s+\=\s+(\S+)/)
 228 |     {
 229 | 		$controlArgs{OUTPUT_EXPECTED_DOSAGE} = $1;
 230 |     }
 231 | }
 232 | close FH1;
 233 | 
 234 | if (! exists $variantFilters{FILTER})
 235 | {
 236 | 	print "\n########\nWARNING - no variant filter options specified\n########\n";
 237 | 	print "The following filters and filter names have been applied by default:\n";
 238 | 	print "GATK_FILTER_EXPRESSION = \"QD < 2.0\" \"QD_lt2\"\n";
 239 | 	print "GATK_FILTER_EXPRESSION = \"FS > 60.0\" \"FS_gt60\"\n";
 240 | 	print "GATK_FILTER_EXPRESSION = \"MQ < 40.0\" \"MQ_lt40\"\n";
 241 | 	print "GATK_FILTER_EXPRESSION = \"ReadPosRankSum < -8.0\" \"ReadPosRankSum_ltm8\"\n";
 242 | 	print "GATK_FILTER_EXPRESSION = \"AF < 0.05\" \"AF_lt05\"\n";
 243 | 	print "GATK_FILTER_EXPRESSION = \"AF > 0.95\" \"AF_gt95\"\n";
 244 | 	print "GATK_FILTER_EXPRESSION = \"DP < 10\" \"DP_lt10\"\n";
 245 | 	my @emergencyFilters = ("QD < 2.0","FS > 60.0","MQ < 40.0","ReadPosRankSum < -8.0","AF < 0.05","AF > 0.95","DP < 10");
 246 | 	my @emergencyFiltersNames = ("QD_lt2","FS_gt60","MQ_lt40","ReadPosRankSum_ltm8","AF_lt05","AF_gt95","DP_lt10");
 247 | 	for my $i (0..(scalar(@emergencyFilters)-1))
 248 | 	{
 249 | 		push @{$variantFilters{FILTER}}, $emergencyFilters[$i];
 250 |         push @{$variantFilters{FILTERNAME}}, $emergencyFiltersNames[$i];
 251 | 	}
 252 | }
 253 | 
 254 | my %taxaPloidy = ();
 255 | open FH1,'<',"$controlArgs{PLOIDY}";
 256 | while (<FH1>)
 257 | {
 258 |     my $line = $_;
 259 |     chomp $line;
 260 |     my @temp = ();
 261 |     @temp = split(/\s+/,$line);
 262 |     if (! exists $taxaPloidy{$temp[0]})
 263 |     {
 264 | 		$taxaPloidy{$temp[0]} = $temp[1];
 265 |     }
 266 |     elsif (exists $taxaPloidy{$temp[0]})
 267 |     {   
 268 | 		die "Duplicate Individual ID $temp[0] in PLOIDY\nThis should be fixed because output data will be lost or incorrect";
 269 |     }
 270 | }
 271 | close FH1;
 272 | 
 273 | #altSeqs are used when for --genotype 1
 274 | #Otherwise refSeqs are the default when building final fasta files
 275 | my %altSeqs = ();
 276 | my %refSeqs = ();
 277 | my %locusList = ();
 278 | my @referenceFasta = glob("$controlArgs{REF}/*.fasta");
 279 | foreach my $rf (@referenceFasta)
 280 | {
 281 |     my $locus = "";
 282 |     my $tax = "";
 283 |     if ($rf =~ m/$controlArgs{REF}\/(\S+)\.fasta/)
 284 |     {
 285 |         $locus = $1;
 286 |         open FH1,'<',"$rf";
 287 |         while (<FH1>)
 288 |         {
 289 |             if (/^>(\S+)/)
 290 |             {
 291 |                 $tax = $1;
 292 |                 if ($tax =~ m/(\S+)\-L\d+$/)
 293 |                 {
 294 |                 	$tax = $1;
 295 |                 }
 296 |                 $refSeqs{$tax}{$locus} = "";
 297 |                 if (! exists $locusList{$locus})
 298 |                 {
 299 |                     $locusList{$locus} = 1;
 300 |                 }
 301 |             }
 302 |             elsif (/(\S+)/)
 303 |             {
 304 |                 my $seq = $1;
 305 |                 $refSeqs{$tax}{$locus} = $refSeqs{$tax}{$locus} . $seq;
 306 |             }
 307 |         }
 308 |         close FH1;
 309 |     }
 310 | }
 311 | 
 312 | foreach my $tax (sort keys %taxaPloidy)
 313 | {
 314 | 	my @fq1 = ();
 315 | 	my @fq2 = ();
 316 | 
 317 |     if ($passedArgs{runmode} eq "species")
 318 |     {
 319 | 		@fq1 = glob("$controlArgs{FQ}/$tax.R1.*");
 320 | 		@fq2 = glob("$controlArgs{FQ}/$tax.R2.*");
 321 | 		system "mkdir $controlArgs{GENOTYPE_OUT}/$tax";
 322 | 		system "mkdir $controlArgs{PHASE_OUT}/$tax";
 323 | 		system "mkdir $controlArgs{IUPAC_OUT}/$tax";
 324 | 		
 325 | 		open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta";
 326 | 		foreach my $locus (sort keys %locusList)
 327 | 		{
 328 | 	    	if (exists $refSeqs{$tax}{$locus})
 329 | 		    {
 330 | 				print OUT1 ">$locus\n$refSeqs{$tax}{$locus}\n";
 331 | 	    	}
 332 | 		}
 333 | 		close OUT1;
 334 | 		open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.genotype.sh";
 335 | 		open FH1,'<',"$passedArgs{template}";
 336 | 		while(<FH1>)
 337 | 		{
 338 | 	    	my $line = $_;
 339 | 	    	chomp $line;
 340 | 		    $line =~ s/__RUNID__/$tax.id/;
 341 | 		    $line =~ s/__LOGFILE__/$tax.log/;
 342 | 	    	print OUT1 "$line\n";
 343 | 		}
 344 | 		close FH1;
 345 | 		print OUT1 "cd $controlArgs{GENOTYPE_OUT}/$tax\n";
 346 | 	
 347 | #####STEP ZERO: Make Reference Databases
 348 | #		print "STEP 0: Preparing Reference Databases\n";
 349 | 		print OUT1 "$controlArgs{PICARD} CreateSequenceDictionary R=$controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n"; 
 350 | 		print OUT1 "$controlArgs{BWA} index $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n";
 351 | 		print OUT1 "$controlArgs{SAMTOOLS} faidx $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n";
 352 | 	
 353 | #####STEP ONE: Map reads
 354 | #		print "STEP 1: Mapping Reads\n";
 355 | 		print OUT1 "$controlArgs{BWA} mem $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta $fq1[0] $fq2[0] | $controlArgs{SAMTOOLS} view -bS -F 4 - | $controlArgs{SAMTOOLS} sort - -o $controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam\n";
 356 | 	
 357 | 		print OUT1 "$controlArgs{PICARD} FastqToSam F1=$fq1[0] F2=$fq2[0] O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.unmapped.bam SM=$controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n";
 358 | 		print OUT1 "$controlArgs{PICARD} MergeBamAlignment ALIGNED=$controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam UNMAPPED=$controlArgs{GENOTYPE_OUT}/$tax/$tax.unmapped.bam O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam R=$controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n";
 359 | 	
 360 | #####STEP TWO: Mark duplicates if needed or skip
 361 | 		if ($controlArgs{REMOVE_READ_DUPLICATES} == 1)
 362 | 		{
 363 | #			print "STEP 2: Marking Duplicates\n";
 364 | 			print OUT1 "$controlArgs{PICARD} MarkDuplicates I=$controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam M=$controlArgs{GENOTYPE_OUT}/$tax/$tax.metrics.txt\n";
 365 | 	
 366 | #######STEP THREE: Identify variants, select only SNPs
 367 | #			print "STEP 3: Identifying variants\n";
 368 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam\n";
 369 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -I $controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam -ploidy $taxaPloidy{$tax} -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.vcf\n";
 370 | 		}
 371 | 		elsif ($controlArgs{REMOVE_READ_DUPLICATES} == 0)
 372 | 		{
 373 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam\n";
 374 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -I $controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam -ploidy $taxaPloidy{$tax} -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.vcf\n";
 375 | 		}
 376 | 		print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf\n"; 
 377 | 		print OUT1 "$controlArgs{GATK} VariantAnnotator -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.vcf -A AlleleFraction -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.ab.vcf\n";
 378 | 		my $gatkfilterstring = "$controlArgs{GATK} VariantFiltration -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.ab.vcf -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.abf.vcf \\";
 379 | 		for my $fn (0..(scalar(@{$variantFilters{FILTER}})-1))
 380 | 		{
 381 | 			if ($fn < (scalar(@{$variantFilters{FILTER}})-1))
 382 | 			{
 383 | 				$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\" \\";
 384 | 			}
 385 | 			elsif ($fn == (scalar(@{$variantFilters{FILTER}})-1))
 386 | 			{
 387 | 				$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\"";
 388 | 			}
 389 | 		}
 390 | 		print OUT1 "$gatkfilterstring\n";
 391 | 		print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.abf.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf\n"; 
 392 | 
 393 | ######STEP FOUR: Output new supercontig FASTA with ambiguity codes
 394 | #		print "STEP 4: Generating IUPAC FASTA file\n";
 395 | 		print OUT1 "$controlArgs{GATK} FastaAlternateReferenceMaker -R $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta -O $controlArgs{IUPAC_OUT}/$tax/$tax.iupac.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf --use-iupac-sample $controlArgs{GENOTYPE_OUT}/$tax/$tax.ref.fasta\n";
 396 | 
 397 | ######STEP FIVE: Split BAM and VCF by locus then phase each locus
 398 | #		print "STEP 5: Splitting BAM and VCF file by locus\n";
 399 | 		print OUT1 "$controlArgs{BAMTOOLS} split -in $controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam -reference\n";
 400 | 		print OUT1 "$controlArgs{BGZIP} -c $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf > $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz\n";
 401 | 		print OUT1 "$controlArgs{TABIX} -p vcf $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz\n";
 402 | 	
 403 | 		foreach my $locus (sort keys %locusList)
 404 | 		{
 405 | 	    	if (exists $refSeqs{$tax}{$locus})
 406 | 		    {
 407 | 				print OUT1 "$controlArgs{TABIX} $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz $locus -h > $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf\n";
 408 | 				my $locusBAM = "$controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.REF_" . "$locus.bam";
 409 | 				print OUT1 "java -jar $controlArgs{HPOPG} -b $locusBAM -v $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf -p $taxaPloidy{$tax} -o $controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.out -d $controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.log\n";
 410 | 			}
 411 | 		}
 412 | ######STEP SIX: BREAK and distribute on cluster
 413 | #		print "STEP 6: Take break to distribute jobs\n";
 414 | 		system "$controlArgs{SCHEDULER} $controlArgs{GENOTYPE_OUT}/$tax/$tax.genotype.sh";
 415 |     }
 416 |     
 417 |     elsif ($passedArgs{runmode} eq "estPloidy")
 418 |     {
 419 | 		@fq1 = glob("$controlArgs{FQ}/$tax.R1.*");
 420 | 		@fq2 = glob("$controlArgs{FQ}/$tax.R2.*");
 421 | 		system "mkdir $controlArgs{ESTPLOIDY_OUT}/$tax";
 422 | 		
 423 | 		open OUT1,'>',"$controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta";
 424 | 		foreach my $locus (sort keys %locusList)
 425 | 		{
 426 | 	    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 427 | 		    {
 428 | 				print OUT1 ">$locus\n$refSeqs{$controlArgs{REFERENCEIND}}{$locus}\n";
 429 | 	    	}
 430 | 		}
 431 | 		close OUT1;
 432 | 		open OUT1,'>',"$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.estPloidy.sh";
 433 | 		open FH1,'<',"$passedArgs{template}";
 434 | 		while(<FH1>)
 435 | 		{
 436 | 	    	my $line = $_;
 437 | 	    	chomp $line;
 438 | 		    $line =~ s/__RUNID__/$tax.id/;
 439 | 		    $line =~ s/__LOGFILE__/$tax.log/;
 440 | 	    	print OUT1 "$line\n";
 441 | 		}
 442 | 		close FH1;
 443 | 		print OUT1 "cd $controlArgs{ESTPLOIDY_OUT}/$tax\n";
 444 | 	
 445 | #####STEP ZERO: Make Reference Databases
 446 | #		print "STEP 0: Preparing Reference Databases\n";
 447 | 		print OUT1 "$controlArgs{PICARD} CreateSequenceDictionary R=$controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n"; 
 448 | 		print OUT1 "$controlArgs{BWA} index $controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 449 | 		print OUT1 "$controlArgs{SAMTOOLS} faidx $controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 450 | 	
 451 | #####STEP ONE: Map reads
 452 | #		print "STEP 1: Mapping Reads\n";
 453 | 		print OUT1 "$controlArgs{BWA} mem $controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta $fq1[0] $fq2[0] | $controlArgs{SAMTOOLS} view -bS -F 4 - | $controlArgs{SAMTOOLS} sort - -o $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.sorted.bam\n";
 454 | 	
 455 | 		print OUT1 "$controlArgs{PICARD} FastqToSam F1=$fq1[0] F2=$fq2[0] O=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.unmapped.bam SM=$controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 456 | 		print OUT1 "$controlArgs{PICARD} MergeBamAlignment ALIGNED=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.sorted.bam UNMAPPED=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.unmapped.bam O=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.merged.bam R=$controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 457 | 	
 458 | #####STEP TWO: Mark duplicates if needed
 459 | 		if ($controlArgs{REMOVE_READ_DUPLICATES} == 1)
 460 | 		{
 461 | #			print "STEP 2: Marking Duplicates\n";
 462 | 			print OUT1 "$controlArgs{PICARD} MarkDuplicates I=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.merged.bam O=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.marked.bam M=$controlArgs{ESTPLOIDY_OUT}/$tax/$tax.metrics.txt\n";
 463 | 	
 464 | #######STEP THREE: Identify variants,. Joint genotyping and filtering happens in later step
 465 | #			print "STEP 3: Identifying variants\n";
 466 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.marked.bam\n";
 467 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -I $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.marked.bam -ploidy 2 -O $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.g.vcf -ERC GVCF\n";
 468 | 		}
 469 | 		elsif ($controlArgs{REMOVE_READ_DUPLICATES} == 0)
 470 | 		{
 471 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.merged.bam\n";
 472 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{ESTPLOIDY_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -I $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.merged.bam -ploidy 2 -O $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.g.vcf -ERC GVCF\n";
 473 | 		}
 474 | 		
 475 | 		system "$controlArgs{SCHEDULER} $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.estPloidy.sh";
 476 |     }
 477 |     
 478 |     elsif ($passedArgs{runmode} eq "population1")
 479 |     {
 480 | 		@fq1 = glob("$controlArgs{FQ}/$tax.R1.*");
 481 | 		@fq2 = glob("$controlArgs{FQ}/$tax.R2.*");
 482 | 		system "mkdir $controlArgs{GENOTYPE_OUT}/$tax";
 483 | 		system "mkdir $controlArgs{PHASE_OUT}/$tax";
 484 | 		system "mkdir $controlArgs{IUPAC_OUT}/$tax";
 485 | 		
 486 | 		open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta";
 487 | 		foreach my $locus (sort keys %locusList)
 488 | 		{
 489 | 	    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 490 | 		    {
 491 | 				print OUT1 ">$locus\n$refSeqs{$controlArgs{REFERENCEIND}}{$locus}\n";
 492 | 	    	}
 493 | 		}
 494 | 		close OUT1;
 495 | 		open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.pop1.sh";
 496 | 		open FH1,'<',"$passedArgs{template}";
 497 | 		while(<FH1>)
 498 | 		{
 499 | 	    	my $line = $_;
 500 | 	    	chomp $line;
 501 | 		    $line =~ s/__RUNID__/$tax.pop1.id/;
 502 | 		    $line =~ s/__LOGFILE__/$tax.pop1.log/;
 503 | 	    	print OUT1 "$line\n";
 504 | 		}
 505 | 		close FH1;
 506 | 		print OUT1 "cd $controlArgs{GENOTYPE_OUT}/$tax\n";
 507 | 	
 508 | #####STEP ZERO: Make Reference Databases
 509 | #		print "STEP 0: Preparing Reference Databases\n";
 510 | 		print OUT1 "$controlArgs{PICARD} CreateSequenceDictionary R=$controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n"; 
 511 | 		print OUT1 "$controlArgs{BWA} index $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 512 | 		print OUT1 "$controlArgs{SAMTOOLS} faidx $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 513 | 	
 514 | #####STEP ONE: Map reads
 515 | #		print "STEP 1: Mapping Reads\n";
 516 | 		print OUT1 "$controlArgs{BWA} mem $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta $fq1[0] $fq2[0] | $controlArgs{SAMTOOLS} view -bS -F 4 - | $controlArgs{SAMTOOLS} sort - -o $controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam\n";
 517 | 	
 518 | 		print OUT1 "$controlArgs{PICARD} FastqToSam F1=$fq1[0] F2=$fq2[0] O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.unmapped.bam SM=$controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 519 | 		print OUT1 "$controlArgs{PICARD} MergeBamAlignment ALIGNED=$controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam UNMAPPED=$controlArgs{GENOTYPE_OUT}/$tax/$tax.unmapped.bam O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam R=$controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta\n";
 520 | 	
 521 | #####STEP TWO: Mark duplicates if needed
 522 | 		if ($controlArgs{REMOVE_READ_DUPLICATES} == 1)
 523 | 		{
 524 | #			print "STEP 2: Marking Duplicates\n";
 525 | 			print OUT1 "$controlArgs{PICARD} MarkDuplicates I=$controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam O=$controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam M=$controlArgs{GENOTYPE_OUT}/$tax/$tax.metrics.txt\n";
 526 | 	
 527 | #######STEP THREE: Identify variants,. Joint genotyping and filtering happens in later step
 528 | #			print "STEP 3: Identifying variants\n";
 529 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam\n";
 530 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -I $controlArgs{GENOTYPE_OUT}/$tax/$tax.marked.bam -ploidy $taxaPloidy{$tax}  -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.g.vcf -ERC GVCF\n";
 531 | 		}
 532 | 
 533 | 		elsif ($controlArgs{REMOVE_READ_DUPLICATES} == 0)
 534 | 		{	
 535 | 			print OUT1 "$controlArgs{SAMTOOLS} index $controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam\n";
 536 | 			print OUT1 "$controlArgs{GATK} HaplotypeCaller -R $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -I $controlArgs{GENOTYPE_OUT}/$tax/$tax.merged.bam -ploidy $taxaPloidy{$tax}  -O $controlArgs{GENOTYPE_OUT}/$tax/$tax.g.vcf -ERC GVCF\n";
 537 | 		}
 538 | 		system "$controlArgs{SCHEDULER} $controlArgs{GENOTYPE_OUT}/$tax/$tax.pop1.sh";
 539 |     }
 540 |     
 541 |     elsif ($passedArgs{runmode} eq "population2")
 542 |     {
 543 |     	open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.pop2.sh";
 544 | 		open FH1,'<',"$passedArgs{template}";
 545 | 		while(<FH1>)
 546 | 		{
 547 | 	    	my $line = $_;
 548 | 	    	chomp $line;
 549 | 		    $line =~ s/__RUNID__/$tax.pop2.id/;
 550 | 		    $line =~ s/__LOGFILE__/$tax.pop2.log/;
 551 | 	    	print OUT1 "$line\n";
 552 | 		}
 553 | 		close FH1;
 554 | 		print OUT1 "cd $controlArgs{GENOTYPE_OUT}/$tax\n";
 555 |     	#######STEP FOUR - continued from pop1: Split the multi-sample vcf into the individual vcf files for processing by the alleles runmode
 556 | 		print OUT1 "$controlArgs{BCFTOOLS} view -c 1 -O v -s $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -o $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf $controlArgs{GENOTYPE_OUT}/joint_genotypes.filtered.biallelic.vcf\n";
 557 | 		
 558 | 		######STEP FIVE: Output new supercontig FASTA with ambiguity codes from the split vcf GIVEN the reference sequence
 559 | 		print OUT1 "$controlArgs{GATK} FastaAlternateReferenceMaker -R $controlArgs{GENOTYPE_OUT}/$tax/$controlArgs{REFERENCEIND}.ref.fasta -O $controlArgs{IUPAC_OUT}/$tax/$tax.iupac.fasta -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf\n";
 560 | 		
 561 | 		######STEP SIX: Split BAM and VCF by locus then phase each locus
 562 | 		print OUT1 "$controlArgs{BAMTOOLS} split -in $controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.bam -reference\n";
 563 | 		print OUT1 "$controlArgs{BGZIP} -c $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf > $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz\n";
 564 | 		print OUT1 "$controlArgs{TABIX} -p vcf $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz\n";
 565 | 	
 566 | 		foreach my $locus (sort keys %locusList)
 567 | 		{
 568 | 	    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 569 | 		    {
 570 | 				print OUT1 "$controlArgs{TABIX} $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.vcf.gz $locus -h > $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf\n";
 571 | 				my $locusBAM = "$controlArgs{GENOTYPE_OUT}/$tax/$tax.sorted.REF_" . "$locus.bam";
 572 | 				print OUT1 "java -jar $controlArgs{HPOPG} -b $locusBAM -v $controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf -p $taxaPloidy{$tax} -o $controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.out -d $controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.log\n";
 573 | 			}
 574 | 		}
 575 | ######STEP SIX: BREAK and distribute on cluster
 576 | #		print "STEP 6: Take break to distribute jobs\n";
 577 | 		system "$controlArgs{SCHEDULER} $controlArgs{GENOTYPE_OUT}/$tax/$tax.pop2.sh";
 578 | 	}
 579 |     
 580 |     
 581 |     elsif ($passedArgs{runmode} eq "alleles")
 582 |     {
 583 | ########
 584 | #Do a quick check to see if we are working with population data
 585 | 		my $ispopulation = 0;
 586 | 		if (-e "$controlArgs{GENOTYPE_OUT}/intervals.list")
 587 | 		{
 588 | 			$ispopulation = 1;
 589 | 		}
 590 | ########    	
 591 | #    	print "STEP 7: Building phased haplotype sequences for $tax\n";
 592 | 		if ($passedArgs{genotype} eq "iupac")
 593 | 		{
 594 | 		    my $af = "$controlArgs{IUPAC_OUT}/$tax/$tax.iupac.fasta";
 595 | 		    my $locus = "";
 596 | 	    	open FH1,'<',"$af";
 597 | 	    	while (<FH1>)
 598 | 	    	{
 599 | 				if (/^>\d+\s+(\S+)\:\d+\-\d+/)
 600 | 				{
 601 | 			    	$locus = $1;
 602 | 			    	$altSeqs{$tax}{$locus} = "";
 603 | 				}
 604 | 				elsif (/(\S+)/)
 605 | 				{
 606 | 		    		my $seq = $1;
 607 | 				    $altSeqs{$tax}{$locus} = $altSeqs{$tax}{$locus} . $seq;
 608 | 				}
 609 | 	    	}
 610 | 		}
 611 |     	foreach my $locus (sort keys %locusList)
 612 | 		{
 613 | 			my $locusdoesexist = 0;
 614 | 			if ($ispopulation == 0)
 615 | 			{
 616 | 		    	if (exists $refSeqs{$tax}{$locus})
 617 | 		    	{
 618 | 		    		$locusdoesexist = 1;
 619 | 		    	}
 620 | 		    }
 621 | 		    elsif ($ispopulation == 1)
 622 | 		    {
 623 | 		    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 624 | 		    	{
 625 | 		    		$locusdoesexist = 1;
 626 | 		    	}
 627 | 		    }
 628 | 		    if ($locusdoesexist == 1)
 629 | 		    {
 630 | 		    	my $variantsDetected = 0;
 631 | 		    	open FH1,'<',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf";
 632 | 		    	while(<FH1>)
 633 | 		    	{
 634 | 		    		if (/\S+\s+\d+\s+\.\s+\S+\s+\S+\s+\S+\s+PASS\s+\S+\s+\S+\s+\S+/)
 635 | 		    		{
 636 | 		    			$variantsDetected++;
 637 | 		    		}
 638 | 		    	}
 639 | 		    	close FH1;
 640 | 		    	
 641 | 		    	if ($variantsDetected > 0)
 642 | 		    	{
 643 | 					my $switch = 0;
 644 | 					my %alleles = ();
 645 | 					my %posMap = ();
 646 | 					my $nsnps = 0;
 647 | 					my %snpList = ();
 648 | 					my %snpMap = ();
 649 | #					print "Processing VCF File - $tax $locus\n";
 650 | 					open FH1,'<',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf";
 651 | 					while(<FH1>)
 652 | 					{
 653 | 				    	my $line = $_;
 654 | 					    chomp $line;
 655 | 			   			if ($switch == 0)
 656 | 			    		{
 657 | 							if ($line =~ m/#CHROM\s+.+/)
 658 | 							{
 659 | 							    $switch = 1;
 660 | 							}
 661 | 		    			}
 662 | 		    			if ($switch == 1)
 663 | 		    			{
 664 | 							if ($line =~ m/\S+\s+(\d+)\s+\.\s+(\S+)\s+(\S+)\s+\S+\s+PASS\s+\S+\s+\S+\s+\S+/)
 665 | 							{
 666 | 						    	my $pos = $1;
 667 | 							    my $a1 = $2;
 668 | 							    my $a2 = $3;
 669 | 				    			$alleles{$pos}{0} = $a1;
 670 | 				    			$alleles{$pos}{1} = $a2;
 671 | 			    				$nsnps++;
 672 | 			    				$posMap{$nsnps} = $pos;
 673 | 			    				$snpList{$pos} = 1;
 674 | 			    				$snpMap{$pos} = $nsnps;
 675 | #			   			 		print "$pos\t$nsnps\t$a1\t$a2\n";
 676 | 							}
 677 | 		    			}
 678 | 					}
 679 | 					close FH1;
 680 | 				
 681 | 					my $fragFile = "$controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.out";
 682 | 					if (-e $fragFile)
 683 | 					{
 684 | 						my %chunks = ();
 685 | 						my $ploidy = 0;
 686 | 						my $maxChunk = 0;
 687 | 						my $nChunks = 0;
 688 | 						my @snpMatrix = ();
 689 | 						my %chunkLength = ();
 690 | 					
 691 | 						open FH1,'<',"$fragFile";
 692 | 						while(<FH1>)
 693 | 						{
 694 | 			   		 		if (/\#BLOCK\:/)
 695 | 		    				{
 696 | 								$nChunks++;
 697 | 								$chunkLength{$nChunks} = 0;
 698 | #								print "Reading Frag - $fragFile BLOCK: $nChunks\n";
 699 | 					    	}
 700 | 						    elsif (/^\*.+/)
 701 | 			    			{
 702 | 								if ($chunkLength{$nChunks} > $maxChunk)
 703 | 								{
 704 | 			    					$maxChunk = $nChunks;
 705 | 								}
 706 | 				    		}
 707 | 					    	elsif (/^(\d+)\s+(.+)/)
 708 | 			    			{
 709 | 								my $snp = $1;
 710 | 								my $vars = $2;
 711 | 								$chunkLength{$nChunks} = $chunkLength{$nChunks} + 1;
 712 | 								my @temp = ();
 713 | 								@temp = split(/\s+/,$vars);
 714 | 								if ($ploidy == 0)
 715 | 								{
 716 | 							    	$ploidy = scalar(@temp);
 717 | 								}
 718 | 								push @{$chunks{$nChunks}}, $snp;
 719 | 								for my $i (0..(scalar(@temp)-1))
 720 | 								{
 721 | 							    	$snpMatrix[$snp][$i+1] = $temp[$i];
 722 | 							    	#print "$snp\t$i\t$temp[$i]\n";
 723 | 								}
 724 | 		    				}
 725 | 						}
 726 | 						close FH1;
 727 | 
 728 | 
 729 | 				    	if ($nChunks > 0)
 730 | 		    			{
 731 | 	    					open OUT1,'>',"$controlArgs{PHASE_OUT}/$tax/$tax.$locus.phased.fasta";
 732 | 	    					for my $i (1..$taxaPloidy{$tax})
 733 | 	    					{
 734 | 								my $thisSeq = "";
 735 | 								if ($passedArgs{genotype} eq "consensus")
 736 | 								{
 737 | 									if ($ispopulation == 0)
 738 | 									{
 739 | 										$thisSeq = $refSeqs{$tax}{$locus};
 740 | 									}
 741 | 									elsif ($ispopulation == 1)
 742 | 									{
 743 | 										$thisSeq = $refSeqs{$controlArgs{REFERENCEIND}}{$locus};
 744 | 									}
 745 | 								}
 746 | 								elsif ($passedArgs{genotype} eq "iupac")
 747 | 								{
 748 | 									$thisSeq = $altSeqs{$tax}{$locus};
 749 | 								}
 750 | 								my $phasedSeq = "";
 751 | 								my @temp = ();
 752 | 								@temp = split(//,$thisSeq);
 753 | 								my %varList = ();
 754 | 								for my $snp (@{$chunks{$maxChunk}})
 755 | 								{
 756 | 								    $varList{$snp} = 1;
 757 | 								}
 758 | 								for my $j (0..(scalar(@temp)-1))
 759 | 								{
 760 | 			    					my $pos = $j+1;
 761 | 				    				if (! exists $snpMap{$pos})
 762 | 			    					{
 763 | 										$phasedSeq = "$phasedSeq" . "$temp[$j]";
 764 | 		   							}
 765 | 		    						elsif (exists $snpMap{$pos})
 766 | 		    						{
 767 | 										if (exists $varList{$snpMap{$pos}})
 768 | 										{
 769 | #			    							print "Phased SNP Found - $pos c=$temp[$j] - 0=$alleles{$pos}{0} 1=$alleles{$pos}{1}\n";
 770 | 								    		if ($snpMatrix[$snpMap{$pos}][$i] =~ m/\d+/)
 771 | 								    		{ 
 772 | 								    			if ($snpMatrix[$snpMap{$pos}][$i] == 0)                                                          
 773 | 				    							{	                                                                                                                    
 774 | 													$phasedSeq = "$phasedSeq" . "$alleles{$pos}{0}";
 775 | 						    					}                                                                                                                         
 776 | 											    elsif ($snpMatrix[$snpMap{$pos}][$i] == 1)  
 777 | 						    					{
 778 | 													$phasedSeq = "$phasedSeq" . "$alleles{$pos}{1}";
 779 | 			    								}
 780 | 											}
 781 | 											elsif ($snpMatrix[$snpMap{$pos}][$i] !~ m/\d+/)
 782 | 											{
 783 | 												if ($snpMatrix[$snpMap{$pos}][$i] eq "-")                                                          
 784 | 			    								{
 785 | 			    									$phasedSeq = "$phasedSeq" . "N";
 786 | 				    							}
 787 | 				    							else
 788 | 				    							{
 789 | 				    								die "Critical Error! SNP Matrix from HPOPG has characters --- $snpMatrix[$snpMap{$pos}][$i] --- it should not\n Stopping until problems are resolved\n";
 790 | 			    								}									
 791 | 											}
 792 | 										}
 793 | 										elsif (! exists $varList{$snpMap{$pos}})
 794 | 										{
 795 | #			    							print "Phased SNP Found on Short end - $pos c=$temp[$j] - 0=$alleles{$pos}{0} 1=$alleles{$pos}{1}\n";
 796 | 								    		if ($passedArgs{genotype} eq "consensus")
 797 | 											{
 798 | 								    			$phasedSeq = "$phasedSeq" . "N";
 799 | 								    		}
 800 | 								    		elsif ($passedArgs{genotype} eq "iupac")
 801 | 											{
 802 | 								    			$phasedSeq = "$phasedSeq" . "$temp[$j]";
 803 | 								    		}
 804 | 										}
 805 | 			    					}
 806 | 								}
 807 | 								my $header = "$tax" . "__" . "$locus" . "__" . "$i";
 808 | 								print OUT1 ">$header\n$phasedSeq\n";
 809 | 	    					}
 810 | 		   					close OUT1;
 811 | 		    			}
 812 | 		    		}
 813 | 		    	}
 814 | 			}
 815 |     	}    	
 816 | 	}
 817 | }
 818 | 
 819 | 
 820 | if ($passedArgs{runmode} eq "estPloidy")
 821 | {
 822 | 	open OUT1,'>',"$controlArgs{ESTPLOIDY_OUT}/intervals.list";
 823 | 	foreach my $locus (sort keys %locusList)
 824 | 	{
 825 | 		if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 826 | 		{
 827 | 	    	print OUT1 "$locus\n";
 828 | 	    }
 829 | 	}
 830 | 	open OUT1,'>',"$controlArgs{ESTPLOIDY_OUT}/jointGenotyping.estPloidy.sh";
 831 | 	open FH1,'<',"$passedArgs{template}";
 832 | 	while(<FH1>)
 833 | 	{
 834 | 	   	my $line = $_;
 835 | 	   	chomp $line;
 836 | 	    $line =~ s/__RUNID__/jointGenotyping.estPloidy.id/;
 837 | 	    $line =~ s/__LOGFILE__/jointGenotyping.estPloidy.log/;
 838 | 	   	print OUT1 "$line\n";
 839 | 	}
 840 | 	close FH1;
 841 | 	print OUT1 "cd $controlArgs{ESTPLOIDY_OUT}\n";
 842 | 	print OUT1 "$controlArgs{GATK} GenomicsDBImport";
 843 | 	foreach my $tax (sort keys %taxaPloidy)
 844 | 	{
 845 | 		print OUT1 " -V $controlArgs{ESTPLOIDY_OUT}/$tax/$tax.g.vcf";
 846 | 	}
 847 | 	print OUT1 " --genomicsdb-workspace-path joint_estPloidy --intervals intervals.list\n";
 848 | 	print OUT1 "$controlArgs{GATK} GenotypeGVCFs -R $controlArgs{ESTPLOIDY_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V gendb://joint_estPloidy -O $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.vcf\n";
 849 | 	print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{ESTPLOIDY_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.biallelic.vcf\n"; 
 850 | 	my $gatkfilterstring = "$controlArgs{GATK} VariantFiltration -R $controlArgs{ESTPLOIDY_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.biallelic.vcf -O $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.filtered.vcf \\";
 851 | 	for my $fn (0..(scalar(@{$variantFilters{FILTER}})-1))
 852 | 	{
 853 | 		if ($fn < (scalar(@{$variantFilters{FILTER}})-1))
 854 | 		{
 855 | 			$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\" \\";
 856 | 		}
 857 | 		elsif ($fn == (scalar(@{$variantFilters{FILTER}})-1))
 858 | 		{
 859 | 			$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\"";
 860 | 		}
 861 | 	}
 862 | 	print OUT1 "$gatkfilterstring\n";
 863 | 	print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{ESTPLOIDY_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.filtered.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.filtered.biallelic.vcf\n"; 
 864 | 
 865 | #######STEP FOUR: Collect ratio of alt reads to ref reads and estimate ploidy with normal mixture model
 866 | 	my $tempsched = "scheduler_" . "$controlArgs{SCHEDULER}";
 867 | 	print OUT1 "perl $controlArgs{HELPERSCRIPTS}/getAB.pl $controlArgs{ESTPLOIDY_OUT}/joint_estPloidy.filtered.biallelic.vcf $controlArgs{ESTPLOIDY_OUT}\n";
 868 | 	foreach my $tax (sort keys %taxaPloidy)
 869 |     {
 870 | 	    print OUT1 "perl $controlArgs{HELPERSCRIPTS}/estimatePloidy.pl $tempsched $controlArgs{PHASING_ROOT}/$passedArgs{template} $controlArgs{ESTPLOIDY_OUT} $controlArgs{HELPERSCRIPTS} $tax\n";
 871 | 	}
 872 | }
 873 | 
 874 | if ($passedArgs{runmode} eq "population1")
 875 | {
 876 | 	open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/intervals.list";
 877 | 	foreach my $locus (sort keys %locusList)
 878 | 	{
 879 | 		if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
 880 | 		{
 881 | 	    	print OUT1 "$locus\n";
 882 | 	    }
 883 | 	}
 884 | 	open OUT1,'>',"$controlArgs{GENOTYPE_OUT}/jointGenotyping.sh";
 885 | 	open FH1,'<',"$passedArgs{template}";
 886 | 	while(<FH1>)
 887 | 	{
 888 | 	   	my $line = $_;
 889 | 	   	chomp $line;
 890 | 	    $line =~ s/__RUNID__/jointGenotyping.id/;
 891 | 	    $line =~ s/__LOGFILE__/jointGenotyping.log/;
 892 | 	   	print OUT1 "$line\n";
 893 | 	}
 894 | 	close FH1;
 895 | 	print OUT1 "cd $controlArgs{GENOTYPE_OUT}\n";
 896 | 	print OUT1 "$controlArgs{GATK} GenomicsDBImport";
 897 | 	foreach my $tax (sort keys %taxaPloidy)
 898 | 	{
 899 | 		print OUT1 " -V $controlArgs{GENOTYPE_OUT}/$tax/$tax.g.vcf";
 900 | 	}
 901 | 	print OUT1 " --genomicsdb-workspace-path joint_genotypes --intervals intervals.list\n";
 902 | 	print OUT1 "$controlArgs{GATK} GenotypeGVCFs -R $controlArgs{GENOTYPE_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V gendb://joint_genotypes -O $controlArgs{GENOTYPE_OUT}/joint_genotypes.vcf\n";
 903 | 	print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{GENOTYPE_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{GENOTYPE_OUT}/joint_genotypes.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{GENOTYPE_OUT}/joint_genotypes.biallelic.vcf\n"; 
 904 | 	my $gatkfilterstring = "$controlArgs{GATK} VariantFiltration -R $controlArgs{GENOTYPE_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{GENOTYPE_OUT}/joint_genotypes.biallelic.vcf -O $controlArgs{GENOTYPE_OUT}/joint_genotypes.filtered.vcf \\";
 905 | 	for my $fn (0..(scalar(@{$variantFilters{FILTER}})-1))
 906 | 	{
 907 | 		if ($fn < (scalar(@{$variantFilters{FILTER}})-1))
 908 | 		{
 909 | 			$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\" \\";
 910 | 		}
 911 | 		elsif ($fn == (scalar(@{$variantFilters{FILTER}})-1))
 912 | 		{
 913 | 			$gatkfilterstring = $gatkfilterstring . "\n --filter-expression \"$variantFilters{FILTER}[$fn]\" --filter-name \"$variantFilters{FILTERNAME}[$fn]\"";
 914 | 		}
 915 | 	}
 916 | 	print OUT1 "$gatkfilterstring\n";
 917 | 	print OUT1 "$controlArgs{GATK} SelectVariants -R $controlArgs{GENOTYPE_OUT}/$controlArgs{REFERENCEIND}/$controlArgs{REFERENCEIND}.ref.fasta -V $controlArgs{GENOTYPE_OUT}/joint_genotypes.filtered.vcf -select-type SNP --restrict-alleles-to BIALLELIC -O $controlArgs{GENOTYPE_OUT}/joint_genotypes.filtered.biallelic.vcf\n"; 
 918 | 
 919 | 	#This job is not automatically submitted since it needs to wait for the individual genotype outputs
 920 | 	print "\nWhen all individual genotyping and gvcf files are completed, submit the joint genotyping file $controlArgs{GENOTYPE_OUT}/jointGenotyping.sh\nYou may consider adjusting the RAM and cpu configuration for this one.\n";
 921 | }
 922 | 
 923 | if ($passedArgs{runmode} eq "alleles")
 924 | {
 925 | #    print "STEP 8: Output fasta files of orthologous phased haplotype sequences\n";
 926 | 	my %phasedSeq = ();
 927 | 	my %tax2phase = ();
 928 | 	
 929 | 	foreach my $tax (sort keys %taxaPloidy)
 930 | 	{
 931 |     	my @phasedFastaFiles = ();
 932 |     	@phasedFastaFiles = glob("$controlArgs{PHASE_OUT}/$tax/$tax.*.phased.fasta");
 933 |     	foreach my $pff (@phasedFastaFiles)
 934 |     	{
 935 | 			if ($pff =~ m/$controlArgs{PHASE_OUT}\/$tax\/$tax\.(\S+)\.phased\.fasta/)
 936 | 			{
 937 | 	    		my $locus = $1;
 938 | 			    my %tempSeq = ();
 939 | 			    my $allele = "";
 940 | 	    		open FH1,'<',"$pff";
 941 | 	    		while (<FH1>)
 942 | 	   			{
 943 | 					if (/^>(\S+)/)
 944 | 					{
 945 | 					    $allele = $1;
 946 | 		    			$allele =~ s/__\S+__/__/;
 947 | 					}
 948 | 					elsif (/(\S+)/)
 949 | 					{
 950 | 		    			my $seq = $1;
 951 | 		   	 			my $switch = 0;
 952 | 					    foreach $allele (keys %tempSeq)
 953 | 		    			{
 954 | 							if ($seq eq $tempSeq{$allele})
 955 | 							{
 956 | ########
 957 | #The UNIQUE_ONLY flag works here by keeping the switch variable always off
 958 | 								if ($controlArgs{UNIQUE_ONLY} == 1)
 959 | 								{
 960 | 									$switch = 1;
 961 | 								}
 962 | ########
 963 | 							}
 964 | 		    			}
 965 | 		    			if ($switch == 0)
 966 | 		    			{
 967 | 							$tempSeq{$allele} = $seq;
 968 | 							$phasedSeq{$locus}{$allele} = $seq;
 969 | 							push @{$tax2phase{$locus}{$tax}}, $allele;
 970 | 		   				}
 971 | 					}
 972 | 	    		}
 973 | 			    close FH1;
 974 | 			}
 975 |     	}
 976 | 	}
 977 | 
 978 | ########
 979 | #Added the pick-one fasta output files 20220214
 980 | #Decided to let randomly chosen alleles retain numbered headers and somebody can always choose to remove the __suffix
 981 | ########
 982 | 
 983 | 	foreach my $locus (sort keys %locusList)
 984 | 	{
 985 |     	open OUT1,'>',"$controlArgs{FASTA_OUT}/PHASED/$locus.fasta";
 986 |     	open OUT2,'>',"$controlArgs{FASTA_OUT}/PICKONE/$locus.fasta";
 987 |     	foreach my $tax (sort keys %taxaPloidy)
 988 |     	{
 989 |     		if ($passedArgs{genotype} eq "consensus")
 990 |     		{
 991 | 				if (exists $refSeqs{$tax}{$locus})
 992 | 				{
 993 | 				    if (exists $tax2phase{$locus}{$tax}[0])
 994 | 	    			{
 995 | 						for my $i (0..(scalar(@{$tax2phase{$locus}{$tax}}) - 1))
 996 | 						{
 997 | 					    	print OUT1 ">$tax2phase{$locus}{$tax}[$i]\n$phasedSeq{$locus}{$tax2phase{$locus}{$tax}[$i]}\n";
 998 | 						}
 999 | 						my $randomAllele = int(rand(scalar(@{$tax2phase{$locus}{$tax}})));
1000 | 						print OUT2 ">$tax2phase{$locus}{$tax}[$randomAllele]\n$phasedSeq{$locus}{$tax2phase{$locus}{$tax}[$randomAllele]}\n";
1001 | 		    		}
1002 | 	    			else
1003 | 				    {
1004 | 				    	if ($controlArgs{OUTPUT_EXPECTED_DOSAGE} == 0)
1005 | 				    	{
1006 | 				    		my $referenceHeader = "$tax" . "__REF";
1007 | 							print OUT1 ">$referenceHeader\n$refSeqs{$tax}{$locus}\n";
1008 | 							print OUT2 ">$referenceHeader\n$refSeqs{$tax}{$locus}\n";
1009 | 						}
1010 | 						elsif ($controlArgs{OUTPUT_EXPECTED_DOSAGE} == 1)
1011 | 				    	{
1012 | 				    		for my $i (1..($taxaPloidy{$tax}))
1013 | 				    		{
1014 | 			    				my $header = "$tax" . "__" . "$i";
1015 | 								print OUT1 ">$header\n$refSeqs{$tax}{$locus}\n";
1016 | 	    					}
1017 | 	    					my $referenceHeader = "$tax" . "__REF";
1018 | 	    					print OUT2 ">$referenceHeader\n$refSeqs{$tax}{$locus}\n";
1019 | 				    	}
1020 | 	    			}
1021 | 				}
1022 | 			}
1023 | 			if ($passedArgs{genotype} eq "iupac")
1024 |     		{
1025 | 				if (exists $altSeqs{$tax}{$locus})
1026 | 				{
1027 | 				    if (exists $tax2phase{$locus}{$tax}[0])
1028 | 	    			{
1029 | 						for my $i (0..(scalar(@{$tax2phase{$locus}{$tax}}) - 1))
1030 | 						{
1031 | 					    	print OUT1 ">$tax2phase{$locus}{$tax}[$i]\n$phasedSeq{$locus}{$tax2phase{$locus}{$tax}[$i]}\n";
1032 | 						}
1033 | 						my $randomAllele = int(rand(scalar(@{$tax2phase{$locus}{$tax}})));
1034 | 						print OUT2 ">$tax2phase{$locus}{$tax}[$randomAllele]\n$phasedSeq{$locus}{$tax2phase{$locus}{$tax}[$randomAllele]}\n";
1035 | 
1036 | 		    		}
1037 | 	    			else
1038 | 				    {
1039 | 				    	if ($controlArgs{OUTPUT_EXPECTED_DOSAGE} == 0)
1040 | 				    	{
1041 | 				    		my $referenceHeader = "$tax" . "__REF";
1042 | 							print OUT1 ">$referenceHeader\n$altSeqs{$tax}{$locus}\n";
1043 | 							print OUT2 ">$referenceHeader\n$altSeqs{$tax}{$locus}\n";
1044 | 	    				}
1045 | 	    				elsif ($controlArgs{OUTPUT_EXPECTED_DOSAGE} == 1)
1046 | 	    				{
1047 | 	    					for my $i (1..($taxaPloidy{$tax}))
1048 | 				    		{
1049 | 			    				my $header = "$tax" . "__" . "$i";
1050 | 								print OUT1 ">$header\n$altSeqs{$tax}{$locus}\n";
1051 | 								print OUT2 ">$header\n$altSeqs{$tax}{$locus}\n";
1052 | 	    					}
1053 | 	    				}
1054 | 	    			}
1055 | 				}
1056 | 			}
1057 |     	}
1058 |     	close OUT1;
1059 |     	close OUT2;
1060 | 	}
1061 | 	
1062 | ########
1063 | #Added per-locus genotype fasta files to FASTA_OUT 20201109
1064 | ########	
1065 | #	print "STEP 9: Output fasta files of orthologous unphased genotype sequences\n";
1066 | 	my %genotypeSeq = ();
1067 | 	foreach my $tax (sort keys %taxaPloidy)
1068 | 	{
1069 | 		open FH1,'<',"$controlArgs{IUPAC_OUT}/$tax/$tax.iupac.fasta";
1070 | 		my $locus = "";
1071 | 		while(<FH1>)
1072 | 		{
1073 | 			if (/^>\S+\s+(\S+)\:\d+\-\d+/)
1074 | 			{
1075 | 				$locus = $1;
1076 | 				$genotypeSeq{$tax}{$locus} = ""; 
1077 | 			}
1078 | 			elsif (/(\S+)/)
1079 | 			{
1080 | 				my $seq = $1;
1081 | 				$genotypeSeq{$tax}{$locus} = $genotypeSeq{$tax}{$locus} . $seq;
1082 | 			}
1083 | 		}
1084 | 		close FH1;
1085 | 	}
1086 | 	
1087 | 	foreach my $locus (sort keys %locusList)
1088 | 	{
1089 | 		open OUT1,'>',"$controlArgs{FASTA_OUT}/GENOTYPE/$locus.fasta";
1090 |     	foreach my $tax (sort keys %taxaPloidy)
1091 |     	{
1092 |     		if (exists $genotypeSeq{$tax}{$locus})
1093 | 			{
1094 |     			print OUT1 ">$tax\n$genotypeSeq{$tax}{$locus}\n";
1095 |     		}
1096 |     	}
1097 |     	close OUT1;
1098 |     }
1099 |     
1100 | ########
1101 | #Added basic phasing stats to SUMMARYSTATS_OUT
1102 | ########
1103 | #	print "STEP 10: Collecting Phasing Statistics\n";
1104 | 	my %phasein = ();
1105 | 	my %alleleCounts = ();
1106 | 	my $maxAlleles = 0;
1107 | 	my %globalStats = ();
1108 | 	my %globalCounts = ();
1109 | 
1110 | 	foreach my $tax (sort keys %taxaPloidy)
1111 | 	{
1112 | 		if ($taxaPloidy{$tax} > $maxAlleles)
1113 | 		{
1114 | 			$maxAlleles = $taxaPloidy{$tax};	
1115 | 		}
1116 |     	foreach my $locus (sort keys %locusList)
1117 | 	    {
1118 | 			my $nvar = 0;
1119 | 			my $nblocks = 0;
1120 | 			my $het = 0;
1121 | 			my $bl = 0;
1122 | 			my $lbl = 0;
1123 | 			
1124 | ################################
1125 | #Do a quick check to see if we are working with population data
1126 | 			my $ispopulation = 0;
1127 | 			if (-e "$controlArgs{GENOTYPE_OUT}/intervals.list")
1128 | 			{
1129 | 				$ispopulation = 1;
1130 | 			}
1131 | ################################
1132 | ################################
1133 | #And a slightly more extraneous way to check if the locus exists based on if we are looking at the de novo or reference sequences
1134 | 			my $locusdoesexist = 0;
1135 | 			if ($ispopulation == 0)
1136 | 			{
1137 | 		    	if (exists $refSeqs{$tax}{$locus})
1138 | 		    	{
1139 | 		    		$locusdoesexist = 1;
1140 | 		    	}
1141 | 		    }
1142 | 		    elsif ($ispopulation == 1)
1143 | 		    {
1144 | 		    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
1145 | 		    	{
1146 | 		    		$locusdoesexist = 1;
1147 | 		    	}
1148 | 		    }
1149 | ################################
1150 | 			if ($locusdoesexist == 1)
1151 | 			{
1152 | 	    		open FH1,'<',"$controlArgs{GENOTYPE_OUT}/$tax/$tax.snps.biallelic.$locus.vcf";
1153 | 			    while (<FH1>)
1154 | 	    		{
1155 | 					if (/PASS/)
1156 | 					{
1157 | 					    $nvar++;
1158 | 					}
1159 | 	    		}
1160 | 			    close FH1;
1161 | 
1162 | 				my $fragFile = "$controlArgs{GENOTYPE_OUT}/$tax/$tax.$locus.phase.out";
1163 | 				if (-e $fragFile)
1164 | 				{
1165 | 					open FH1,'<',"$fragFile";
1166 | 					#BLOCK: offset: 1 len: 19 phased: 76
1167 | 					while (<FH1>)
1168 | 					{
1169 | 					    if(/#BLOCK:\s+offset:\s+\d+\s+len:\s+(\d+)\s+phased:\s+\d+/)
1170 | 		    			{
1171 | 							$bl = $1;
1172 | 							if ($bl > $lbl)
1173 | 							{
1174 | 			    				$lbl = $bl;
1175 | 							}
1176 | 							$nblocks++;
1177 | 		    			}
1178 | 					}
1179 | 					close FH1;
1180 | 					
1181 | 					if ($ispopulation == 0)
1182 | 					{
1183 | 		    			$het = $nvar/(length($refSeqs{$tax}{$locus}));
1184 | 		    		}
1185 | 		    
1186 | 		    		elsif ($ispopulation == 1)
1187 | 		   	 		{
1188 | 		    			$het = $nvar/(length($refSeqs{$controlArgs{REFERENCEIND}}{$locus}));
1189 | 		    		}
1190 | 		    	}
1191 | 			}
1192 | 			$phasein{$tax}{$locus}{nvar} = $nvar;
1193 | 			$phasein{$tax}{$locus}{het} = $het;
1194 | 			$phasein{$tax}{$locus}{nblocks} = $nblocks;
1195 | 			$phasein{$tax}{$locus}{lbl} = $lbl;
1196 | 		}
1197 | 	}
1198 | 
1199 | 	foreach my $locus (sort keys %locusList)
1200 | 	{
1201 |     	open FH1,'<',"$controlArgs{FASTA_OUT}/PHASED/$locus.fasta";
1202 |     	while (<FH1>)
1203 |     	{
1204 | 			if (/^>(\S+)\_\_\S+/)
1205 | 			{
1206 | 			    my $tax = $1;
1207 | 	   			if (! exists $alleleCounts{$tax}{$locus})
1208 | 			    {
1209 | 					$alleleCounts{$tax}{$locus} = 1;
1210 | 	   			}
1211 | 	   			elsif (exists $alleleCounts{$tax}{$locus})
1212 | 	   			{   
1213 | 					$alleleCounts{$tax}{$locus} = $alleleCounts{$tax}{$locus} + 1;
1214 | 	   			}
1215 | 			}
1216 |     	}
1217 |     	close FH1;
1218 | 	}
1219 | 
1220 | ########
1221 | #Print out all per-locus stats per individual as well as the global counts that are average over present loci
1222 | ########
1223 | 	
1224 | 	foreach my $tax (sort keys %taxaPloidy)
1225 | 	{
1226 |     	open OUT1,'>',"$controlArgs{SUMMARYSTATS_OUT}/$tax.phasingSummary.txt";
1227 | 		print OUT1 "LOCUS\tLENGTH\tNVAR\tHET\tNBLOCKS\tLONGESTBL";
1228 | 		for my $i (1..$maxAlleles)
1229 | 		{
1230 | 			print OUT1 "\t$i";
1231 | 			$globalCounts{$tax}{$i} = 0;
1232 | 		}
1233 | 		print OUT1 "\n";
1234 | 		$globalStats{$tax}{nloci} = 0;
1235 | 		$globalStats{$tax}{ninvarloci} = 0;
1236 | 		$globalStats{$tax}{nvarloci} = 0;
1237 | 		$globalStats{$tax}{nphaseloci} = 0;
1238 | 		$globalStats{$tax}{loclen} = 0;
1239 | 		$globalStats{$tax}{nvar} = 0;
1240 | 		$globalStats{$tax}{het} = 0;
1241 | 		$globalStats{$tax}{nblocks} = 0;
1242 | 		$globalStats{$tax}{lbl} = 0;
1243 | 		
1244 | 	    foreach my $locus (sort keys %locusList)
1245 |     	{
1246 | ################################
1247 | #Do a quick check to see if we are working with population data
1248 | 			my $ispopulation = 0;
1249 | 			if (-e "$controlArgs{GENOTYPE_OUT}/intervals.list")
1250 | 			{
1251 | 				$ispopulation = 1;
1252 | 			}
1253 | ################################
1254 | ################################
1255 | #And a slightly more extraneous way to check if the locus exists based on if we are looking at the de novo or reference sequences
1256 | 			my $locusdoesexist = 0;
1257 | 			if ($ispopulation == 0)
1258 | 			{
1259 | 		    	if (exists $refSeqs{$tax}{$locus})
1260 | 		    	{
1261 | 		    		$locusdoesexist = 1;
1262 | 		    	}
1263 | 		    }
1264 | 		    elsif ($ispopulation == 1)
1265 | 		    {
1266 | 		    	if (exists $refSeqs{$controlArgs{REFERENCEIND}}{$locus})
1267 | 		    	{
1268 | 		    		($locusdoesexist = 1);
1269 | 		    	}
1270 | 		    }
1271 | ################################
1272 | 			if ($locusdoesexist == 1)
1273 | 			{	
1274 | 				my $refLen = 0;
1275 | 				if ($ispopulation == 0)
1276 | 				{
1277 | 					$refLen = length($refSeqs{$tax}{$locus});
1278 | 				}
1279 | 				elsif ($ispopulation == 1)
1280 | 				{
1281 | 					$refLen = length($refSeqs{$controlArgs{REFERENCEIND}}{$locus});
1282 | 				}
1283 | 	    		
1284 | 	    		if (exists $alleleCounts{$tax}{$locus})
1285 | 	    		{
1286 | 	    			print OUT1 "$locus\t$refLen\t$phasein{$tax}{$locus}{nvar}\t$phasein{$tax}{$locus}{het}\t$phasein{$tax}{$locus}{nblocks}\t$phasein{$tax}{$locus}{lbl}";
1287 | 	    			for my $i (1..$maxAlleles)
1288 | 	    			{
1289 | 	    				if ($alleleCounts{$tax}{$locus} == $i)
1290 | 	    				{
1291 | 							print OUT1 "\t1";
1292 | 							$globalCounts{$tax}{$i} = $globalCounts{$tax}{$i} + 1;
1293 | 						}
1294 | 						else
1295 | 						{
1296 | 							print OUT1 "\t0";
1297 | 						}
1298 | 	    			}
1299 | 					print OUT1 "\n";
1300 | 				
1301 | 				
1302 | 					$globalStats{$tax}{nloci} = $globalStats{$tax}{nloci} + 1;
1303 | 					$globalStats{$tax}{loclen} = $globalStats{$tax}{loclen} + $refLen;
1304 | 				
1305 | 					if ($phasein{$tax}{$locus}{nblocks} > 0 && $phasein{$tax}{$locus}{nvar} > 0)
1306 | 					{
1307 | 						$globalStats{$tax}{nvar} = $globalStats{$tax}{nvar} + $phasein{$tax}{$locus}{nvar};
1308 | 						$globalStats{$tax}{het} = $globalStats{$tax}{het} + $phasein{$tax}{$locus}{het};
1309 | 						$globalStats{$tax}{nblocks} = $globalStats{$tax}{nblocks} + $phasein{$tax}{$locus}{nblocks};
1310 | 						$globalStats{$tax}{lbl} = $globalStats{$tax}{lbl} + $phasein{$tax}{$locus}{lbl};
1311 | 						$globalStats{$tax}{nphaseloci} = $globalStats{$tax}{nphaseloci} + 1;
1312 | 						$globalStats{$tax}{nvarloci} = $globalStats{$tax}{nvarloci} + 1;
1313 | 					}
1314 | 					if ($phasein{$tax}{$locus}{nblocks} == 0 && $phasein{$tax}{$locus}{nvar} == 0)
1315 | 					{
1316 | 						$globalStats{$tax}{ninvarloci} = $globalStats{$tax}{ninvarloci} + 1;
1317 | 					}
1318 | 					if ($phasein{$tax}{$locus}{nblocks} == 0 && $phasein{$tax}{$locus}{nvar} > 0)
1319 | 					{
1320 | 						$globalStats{$tax}{nvar} = $globalStats{$tax}{nvar} + $phasein{$tax}{$locus}{nvar};
1321 | 						$globalStats{$tax}{het} = $globalStats{$tax}{het} + $phasein{$tax}{$locus}{het};
1322 | 						$globalStats{$tax}{nvarloci} = $globalStats{$tax}{nvarloci} + 1;
1323 | 					}
1324 | 					if ($phasein{$tax}{$locus}{nblocks} > 0 && $phasein{$tax}{$locus}{nvar} == 0)
1325 | 					{
1326 | 						print "Critical error: Cannot have phased loci without passing variants!\n"
1327 | 					}
1328 | 				}
1329 | 				if (! exists $alleleCounts{$tax}{$locus})
1330 | 	    		{
1331 | 	    			print OUT1 "$locus\t0\t0\t0\t0\t0";
1332 | 					for my $i (1..$maxAlleles)
1333 | 	    			{
1334 | 	    				print OUT1 "\tNA";
1335 | 		    		}
1336 | 		    		print OUT1 "\n";
1337 | 	    		}
1338 | 			}
1339 | 			elsif ($locusdoesexist == 0)
1340 | 			{
1341 | 				print OUT1 "$locus\t0\t0\t0\t0\t0";
1342 | 				for my $i (1..$maxAlleles)
1343 | 	    		{
1344 | 	    			print OUT1 "\tNA";
1345 | 	    		}
1346 | 	    		print OUT1 "\n";
1347 | 			}
1348 |     	}
1349 |     	close OUT1;
1350 |     }
1351 |     
1352 |     open OUT1,'>',"$controlArgs{SUMMARYSTATS_OUT}/averagePhasingStats.txt";
1353 |     print OUT1 "INDIVIDUAL\tNLOCI\tNVARLOCI\tNINVLOCI\tNPHASELOCI\tAVG_LENGTH\tAVG_NVAR\tAVG_HET\tAVG_NBLOCKS\tAVG_LONGESTBL";
1354 |     for my $i (1..$maxAlleles)
1355 | 	{
1356 | 		print OUT1 "\t$i";
1357 | 	}
1358 | 	print OUT1 "\n";
1359 | 	foreach my $tax (sort keys %taxaPloidy)
1360 | 	{
1361 | 		if ($globalStats{$tax}{nloci} > 0)
1362 | 		{
1363 | 			$globalStats{$tax}{loclen} = $globalStats{$tax}{loclen}/$globalStats{$tax}{nloci};
1364 | 			$globalStats{$tax}{nvar} = $globalStats{$tax}{nvar}/$globalStats{$tax}{nloci};
1365 | 			$globalStats{$tax}{het} = $globalStats{$tax}{het}/$globalStats{$tax}{nloci};
1366 | 			if ($globalStats{$tax}{nphaseloci} > 0)
1367 | 			{
1368 | 				$globalStats{$tax}{nblocks} = $globalStats{$tax}{nblocks}/$globalStats{$tax}{nphaseloci};
1369 | 				$globalStats{$tax}{lbl} = $globalStats{$tax}{lbl}/$globalStats{$tax}{nphaseloci};
1370 | 			}
1371 | 			print OUT1 "$tax\t$globalStats{$tax}{nloci}\t$globalStats{$tax}{nvarloci}\t$globalStats{$tax}{ninvarloci}\t$globalStats{$tax}{nphaseloci}\t$globalStats{$tax}{loclen}\t$globalStats{$tax}{nvar}\t$globalStats{$tax}{het}\t$globalStats{$tax}{nblocks}\t$globalStats{$tax}{lbl}";
1372 | 		}
1373 | 		elsif ($globalStats{$tax}{nloci} == 0)
1374 | 		{
1375 | 			print OUT1 "$tax\t0\t0\t0\t0\t0\t0\t0\t0\t0";
1376 | 		}
1377 | 		for my $i (1..$maxAlleles)
1378 | 		{
1379 | 			if ($i <= $taxaPloidy{$tax})
1380 | 			{
1381 | 				print OUT1 "\t$globalCounts{$tax}{$i}";
1382 | 			}
1383 | 			elsif ($i > $taxaPloidy{$tax})
1384 | 			{
1385 | 				print OUT1 "\tNA";
1386 | 			}
1387 | 		}
1388 | 		print OUT1 "\n";
1389 | 	}
1390 | 	close OUT1;
1391 | }
1392 | exit;
1393 | 


--------------------------------------------------------------------------------