#======================================================================
#                    L A D C P P R O C . B T 
#                    doc: Wed Oct 20 21:05:37 2010
#                    dlm: Tue Aug  5 14:38:08 2014
#                    (c) 2010 A.M. Thurnherr
#                    uE-Info: 205 0 NIL 0 0 72 10 2 4 NIL ofnI
#======================================================================

# HISTORY:
#	Oct 20, 2010: - created
#	Jan 10, 2010: - -o => -k
#	Jul  7, 2010: - added $DEBUG
#				  - added BTrangeFlag
#				  - added $BT processing parameters
#				  - changed from echo amplitude to Sv
#	May 16, 2012: - added support for -r)DI BT data
#	Sep 19, 2013: - added support for $BT_range_method
#	Aug  5, 2014: - BUG: invalid velocities were used; see July 15 bug fix
#						 in [LADCPproc.shearmethod]
#				  - artifically removed BT profile data apparently below
#				    seabed but that had passed previous tests

my($BEAM1) = 0;
my($BEAM2) = 1;
my($BEAM3) = 2;
my($BEAM4) = 3;

my($nBTfound,$nBTrangeFlag,$nBTdepthFlag,$nBTvalidVelFlag,$nBTwFlag) = (0,0,0,0,0);

my($DEBUG) = 0;

sub CTDvelFromSv($)
{
	my($ens) = @_;

	my(@Sv_max) = (-9e99,-9e99,-9e99,-9e99); my(@Sv_max_bin) = (nan,nan,nan,nan);
	for (my($bin)=$BT_bin_start-1; $bin<$LADCP{N_BINS}; $bin++) {
		if (defined($BT_min_depth)) {								# manually supplied bottom depth range
			my($dob) = &depthOfBin($ens,$bin);
			next unless ($dob >= $BT_min_depth && $dob <= $BT_max_depth);
		}
		$Sv_max[$BEAM1] = $LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM1],
		$Sv_max_bin[$BEAM1] = $bin
			if ($LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM1] > $Sv_max[$BEAM1]);
		$Sv_max[$BEAM2] = $LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM2],
		$Sv_max_bin[$BEAM2] = $bin
			if ($LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM2] > $Sv_max[$BEAM2]);
		$Sv_max[$BEAM3] = $LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM3],
		$Sv_max_bin[$BEAM3] = $bin
			if ($LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM3] > $Sv_max[$BEAM3]);
		$Sv_max[$BEAM4] = $LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM4],
		$Sv_max_bin[$BEAM4] = $bin
			if ($LADCP{ENSEMBLE}[$ens]->{SV}[$bin][$BEAM4] > $Sv_max[$BEAM4]);
	}

	print(STDERR "@Sv_max | @Sv_max_bin\n") if ($DEBUG);
	$nBTfound++;

	$nBTrangeFlag++,return											# inconsistent range (&, impliclity, large tilt)
		unless (max(@Sv_max_bin)-min(@Sv_max_bin) <= $BT_max_bin_spread);

	my($range_bin) = round(avg(@Sv_max_bin));
	printf(STDERR "water_depth = $water_depth; BT peak depth = %d in bin $range_bin\n",depthOfBin($ens,$range_bin))
		if ($DEBUG);

	$nBTdepthFlag++,return											# BT range inconsistent with water depth
		unless defined($BT_min_depth) ||
			   (abs($water_depth-depthOfBin($ens,$range_bin)) < $sig_water_depth + $BT_max_depth_error);

	my($CTD_u,$CTD_v,$CTD_w);
	
	if ($BT_range_method == 0) {										# take BT vel from bin with Sv max
		
		$nBTvalidVelFlag++,return unless numberp($LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$W]);
		$CTD_u = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$U];
		$CTD_v = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$V];
		$CTD_w = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$W];
		
	} elsif ($BT_range_method == 1) {									# take "best-fit" with w_reflr

		# try bin of max plus one above and below
		# this does not really work because, often, only one of the bins has valid velocities
		my($w1) = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin-1][$W];
		my($w2) = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$W];
		my($w3) = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+1][$W];
	
		printf(STDERR "w123 = %.1f,%.1f,%.1f\n",$w1,$w2,$w3)
			if ($DEBUG);
	
		$w1 = 9e99 unless numberp($w1); 								# no valid velocities
		$w2 = 9e99 unless numberp($w1);
		$w3 = 9e99 unless numberp($w1);
	
		if (abs($LADCP{ENSEMBLE}[$ens]->{W}-$w1) < abs($LADCP{ENSEMBLE}[$ens]->{W}-$w2) &&
			abs($LADCP{ENSEMBLE}[$ens]->{W}-$w1) < abs($LADCP{ENSEMBLE}[$ens]->{W}-$w3)) {
				$CTD_u = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin-1][$U];
				$CTD_v = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin-1][$V];
				$CTD_w = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin-1][$W];
		} elsif (abs($LADCP{ENSEMBLE}[$ens]->{W}-$w1) < abs($LADCP{ENSEMBLE}[$ens]->{W}-$w2)) {
				$CTD_u = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+1][$U];
				$CTD_v = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+1][$V];
				$CTD_w = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+1][$W];
		} else {
				$nBTvalidVelFlag++,return if ($w2 == 9e99); 			# none of 3 bins has valid velocity
				$CTD_u = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$U];
				$CTD_v = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$V];
				$CTD_w = $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin][$W];
	    }

	} elsif ($BT_range_method == 2) {									# Visbeck method (median from 3 bins)
		croak("$0: need \$BT_range_Visbeck_center\n")
			unless defined($BT_range_Visbeck_center);

		$CTD_u = median($LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center+1][$U],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center][$U],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center-1][$U]);
		$nBTvalidVelFlag++,return unless numberp($CTD_u);
		$CTD_v = median($LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center+1][$V],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center][$V],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center-1][$V]);
		$CTD_w = median($LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center+1][$W],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center][$W],
						$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$range_bin+$BT_range_Visbeck_center-1][$W]);
		
	} else {
		
		croak("$0: unknown \$BT_range_method == $BT_range_method\n");
	}
			

	return ($CTD_u,$CTD_v,$CTD_w);
}

sub depthAtRange($$)
{
	my($ens,$range) = @_;
	return $LADCP{ENSEMBLE}[$ens]->{XDUCER_FACING_UP} ?
	       $LADCP{ENSEMBLE}[$ens]->{DEPTH} - $range :
	       $LADCP{ENSEMBLE}[$ens]->{DEPTH} + $range;
}

sub CTDvelFromBT($)
{
	my($ens) = @_;

	return (undef,undef,undef)
		unless defined($LADCP{ENSEMBLE}[$ens]->{BT_VELOCITY}[$W]);
	$nBTfound++;

	$nBTrangeFlag++,return											# inconsistent range (&, impliclity, large tilt)
		unless (max(@{$LADCP{ENSEMBLE}[$ens]->{BT_RANGE}})-min(@{$LADCP{ENSEMBLE}[$ens]->{BT_RANGE}})
					<= $BT_max_bin_spread*$LADCP{BIN_LENGTH});

	my($range) = round(avg(@{$LADCP{ENSEMBLE}[$ens]->{BT_RANGE}}));

	$nBTdepthFlag++,return											# BT range inconsistent with water depth
		unless defined($BT_min_depth) ||
			   (abs($water_depth-depthAtRange($ens,$range)) < $sig_water_depth + $BT_max_depth_error);

	return ($LADCP{ENSEMBLE}[$ens]->{BT_VELOCITY}[$U],
			$LADCP{ENSEMBLE}[$ens]->{BT_VELOCITY}[$V],
			$LADCP{ENSEMBLE}[$ens]->{BT_VELOCITY}[$W]);
}


sub binBTprof($)
{
	my($ens) = @_;
	my($CTD_u,$CTD_v,$CTD_w);

	($CTD_u,$CTD_v,$CTD_w) = $opt_r ? CTDvelFromBT($ens) : CTDvelFromSv($ens);
	return unless defined($CTD_w);

	$nBTwFlag++,return if (abs($CTD_w-$LADCP{ENSEMBLE}[$ens]->{W}) > $BT_max_w_difference);

	printf(STDERR "good BT [%5.2f %5.2f %5.2f] found at ens $ens\n",$CTD_u,$CTD_v,$CTD_w)
		if ($DEBUG);

	if ($opt_k) {
		for (my($bin)=$BT_bin_start-1; $bin<$LADCP{N_BINS}; $bin++) {
			next if ($edit_flags[$ens][$bin] || $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$W]==0);
			printf(BTF "%d %d %d %f %f %f %f %f %f %f %f %f %f %f\n",
				$LADCP{ENSEMBLE}[$ens]->{NUMBER},
				depthOfBin($ens,$bin),$LADCP{ENSEMBLE}[$ens]->{DEPTH},
				$LADCP{ENSEMBLE}[$ens]->{PITCH},$LADCP{ENSEMBLE}[$ens]->{ROLL},
				$CTD_u,$CTD_v,$CTD_w,
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$U],
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$V],
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$W],
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$U]-$CTD_u,
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$V]-$CTD_v,
				$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$W]-$CTD_w);
		}
	    print(BTF "nan nan nan nan\n");
	}

	for (my($bin)=$BT_bin_start-1; $bin<$LADCP{N_BINS}; $bin++) {
		next if ($edit_flags[$ens][$bin] || $LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$W]==0);
		my($dob) = depthOfBin($ens,$bin);
		next if ($dob > $water_depth);
		my($gi) = int($dob / $GRID_DZ);
		push(@{$BTu_vals[$gi]},$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$U]-$CTD_u);
		push(@{$BTv_vals[$gi]},$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$V]-$CTD_v);
		push(@{$BTw_vals[$gi]},$LADCP{ENSEMBLE}[$ens]->{VELOCITY}[$bin][$W]-$CTD_w);
	}
}

sub getBTprof($$)
{
	my($LADCP_start,$LADCP_end) = @_;

	if ($opt_k) {
		open(BTF,">BT.profs");
	    print(BTF "#ANTS#FIELDS# {ens} {depth} {CTD_depth} {pitch} {roll} {CTD_u} {CTD_v} {CTD_w} {u} {v} {w} {BT_u} {BT_v} {BT_w}\n");
	}

	for (my($ens)=$LADCP_start; $ens<=$LADCP_end; $ens++) {
		next unless ($water_depth-$LADCP{ENSEMBLE}[$ens]->{DEPTH} < $BT_begin_search_above);
		binBTprof($ens);
	}

	if ($opt_d) {
		print(STDERR "\n\t$nBTfound BT ensembles found\n");
	    print(STDERR "\t\t$nBTrangeFlag flagged bad because of inconsistent range to seabed\n");
	    print(STDERR "\t\t$nBTdepthFlag flagged bad because of wrong bottom depth\n");
	    print(STDERR "\t\t$nBTvalidVelFlag flagged bad because of lack of valid velocities\n");
	    print(STDERR "\t\t$nBTwFlag flagged bad because of incorrect vertical velocities");
	    printf(STDERR "\n\t=> %d velocities from %d BT ensembles used",
	    				scalar(@BTu_vals),
						$nBTfound-$nBTrangeFlag-$nBTdepthFlag-$nBTvalidVelFlag-$nBTwFlag);
	}

	@BTu  = @BTv  = @BTw  = ();
	@BTu_sig = @BTv_sig = @BTw_sig = ();
	@BT_nsamp = ();

	for (my($gi)=0; $gi<@BTu_vals; $gi++) {								# calc grid means & stddev
		my($sum_u,$sum_v,$sum_w);

		$BT_nsamp[$gi] = @{$BTu_vals[$gi]};
		
		for (my($vi)=0; $vi<$BT_nsamp[$gi]; $vi++) {
			$sum_u += $BTu_vals[$gi][$vi];
			$sum_v += $BTv_vals[$gi][$vi];
			$sum_w += $BTw_vals[$gi][$vi];
		}
		$BTu[$gi] = $BT_nsamp[$gi] ? $sum_u/$BT_nsamp[$gi] : nan;
		$BTv[$gi] = $BT_nsamp[$gi] ? $sum_v/$BT_nsamp[$gi] : nan;
		$BTw[$gi] = $BT_nsamp[$gi] ? $sum_w/$BT_nsamp[$gi] : nan;
	}

	for (my($gi)=0; $gi<@BTu_vals; $gi++) {								# calc & grid stddevs
		my($sumsq_u,$sumsq_v,$sumsq_w);
		for (my($vi)=0; $vi<$BT_nsamp[$gi]; $vi++) {
			$sumsq_u += ($BTu_vals[$gi][$vi] - $BTu[$gi])**2;
			$sumsq_v += ($BTv_vals[$gi][$vi] - $BTv[$gi])**2;
			$sumsq_w += ($BTw_vals[$gi][$vi] - $BTw[$gi])**2;
		}
		$BTu_sig[$gi] = $BT_nsamp[$gi]>1 ? sqrt($sumsq_u/($BT_nsamp[$gi]-1)) : nan;
		$BTv_sig[$gi] = $BT_nsamp[$gi]>1 ? sqrt($sumsq_v/($BT_nsamp[$gi]-1)) : nan;
		$BTw_sig[$gi] = $BT_nsamp[$gi]>1 ? sqrt($sumsq_w/($BT_nsamp[$gi]-1)) : nan;
	}

	close(BTF) if ($opt_k);
}

1;