perl实例

#!/opt/perl/5.8.0/bin/perl
#ident "%W%"

$run_time = &timestamp();

#$asof = substr($run_time, 0,

;
$asof = $ARGV[0];
$default_stale_cutoff = $ARGV[1];
$default_stale_cutoff = 30 if $default_stale_cutoff <= 0;

$light_yellow="#FFFF88";
$light_red="#FC8E8E";
$orange="#FFA500";

$emct_subord_map->{"SENIOR_UNSECURED"} = "sen";
$emct_subord_map->{"SENIOR_SECURED"} = "sensec";
$emct_subord_map->{"SUBORDINATE"} = "sub";

$ca_subord_map->{"SENIOR_UNSECURED"} = "sen";
$ca_subord_map->{"SENIOR_SECURED"} = "sensec";
$ca_subord_map->{"SUBORDINATE"} = "sub";

$tennor_map->{"3M"} = "3M";
$tennor_map->{"6M"} = "6M";
$tennor_map->{"1Y"} = "1Y";
$tennor_map->{"2Y"} = "2Y";
$tennor_map->{"3Y"} = "3Y";
$tennor_map->{"4Y"} = "4Y";
$tennor_map->{"5Y"} = "5Y";
$tennor_map->{"7Y"} = "7Y";
$tennor_map->{"10Y"} = "10Y";
$tennor_map->{"15Y"} = "15Y";
$tennor_map->{"20Y"} = "20Y";
$tennor_map->{"30Y"} = "30Y";

# load excluded list
$basedir = $ENV{"GCDR_BASEDIR"};
open(EX_FILE, "< $basedir/config/excluded.txt");
print "open file $basedir/config/excluded.txt\n";
while ($line = <EX_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^\|exclude_type\s*\|ticker\s*\|reason\s*\|/)
 {next;}
 ($dummy,
 $excluded_type,
 $ticker,
 $reason) = split (/\s*\|\s*|\|/, $line);

 $excluded_list->{$excluded_type}->{$ticker} = $reason;
}
close(EX_FILE);

open(MAP_FILE, "< subord_map_$asof.txt");
while ($line = <MAP_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^\|code\s*\|name\s*\|/)
 {next;}
 ($dummy,
 $code,
 $name) = split (/\s*\|\s*|\|/, $line);

 $subord_map->{$code} = $name;
}
close(MAP_FILE);

open(MAP_FILE, "< curve_type_map_$asof.txt");
while ($line = <MAP_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^\|type\s*\|name\s*\|/)
 {next;}
 ($dummy,
 $type,
 $name) = split (/\s*\|\s*|\|/, $line);
 $curve_type_map->{$type} = $name;
}
close(MAP_FILE);

open(MAP_FILE, "< desk_map_$asof.txt");
while ($line = <MAP_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^\|owner_code\s*\|label\s*\|/)
 {next;}
 ($dummy,
 $desk,
 $label) = split (/\s*\|\s*|\|/, $line);
 $desk_map->{$desk} = $label;
}
close(MAP_FILE);

open(MAP_FILE, "< sector_map_$asof.txt");
while ($line = <MAP_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^\|sector_id\s*\|owner_code\s*\|label\s*\|/)
 {next;}
 ($dummy,
 $sector_id, $desk, $label) = split (/\s*\|\s*|\|/, $line);
 $sector_map->{$sector_id}->{desk} = $desk;
 $sector_map->{$sector_id}->{label} = $label;
}
close(MAP_FILE);

open(USER_FILE, "< user_file_${asof}.txt");
while ($line = <USER_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^username/)
 {next;}
 ($dummy, $user_id, $name) = split (/\s*\|\s*|\|/, $line);

 $username_map->{$user_id} = $name;
}
close(USER_FILE);

open(ISSUER_FILE, "< issuer_map_${asof}.txt");
while ($line = <ISSUER_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^issuer_id/)
 {next;}
 ($dummy, $issuer_id, $ticker, $name, $sector_id) = split (/\s*\|\s*|\|/, $line);

 $issuer_sector_map->{$issuer_id} = $sector_id;
}
close(ISSUER_FILE);

open(SNAP_FILE, "< stale_snapshot_${asof}.txt");
while ($line = <SNAP_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^curve_id/)
 {next;}
 ($curve_id, $last_date) = split (/\s*\|\s*|\|/, $line);

 $last_change_date->{$curve_id} = $last_date;
}
close(SNAP_FILE);

open(BLOTTER_FILE, "< blotter_file_${asof}.txt");
while ($line = <BLOTTER_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 if ($line =~ /^instrument_id/)
 {next;}
 ($dummy, $curve_id, $owner_code) = split (/\s*\|\s*|\|/, $line);

 $blotter_id_sector_map->{$curve_id} = $owner_code;
}
close(BLOTTER_FILE);

open(CURVE_FILE, "< GCDR.curves_${asof}_1830.revised") or print "Cannot open GCDR.curves_${asof}_1830.revised\n";
while ($line = <CURVE_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^issuerName\|issuerShortCode/)
 {next;}
 ($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
 $curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
 $snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
 $curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

 if ($curveStatus ne "ok") {next;}

 #AP
 $gcdr_curves->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType}->{$curveSource} = $curveId;

 if ($curveSource eq "pc") {
 $pc_map_list->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType} = $curveId;

 $issuer_map->{$curveId}->{ticker} = $issuerShortCode;
 $issuer_map->{$curveId}->{subord} = $curveSubord;
$issuer_sector_id = $issuer_sector_map->{$issuerId};
 $ticker_sector_map->{$issuerShortCode} = &get_sector_label($issuer_sector_id);
 } elsif ($curveExternalName ne "NULL") {
 $src_id_to_name->{$curveId} = $curveExternalName;
 $src_name_to_ticker->{$curveSource}->{$curveExternalName} = $issuerShortCode;
 $src_name_to_subord->{$curveSource}->{$curveExternalName} = $curveSubord;
 }

 if ($curveSource eq "blotter") {
 $src_id_to_name->{$curveId} = $curveShortCode;
 }
}
close(CURVE_FILE);

open(CURVE_FILE, "< GCDR.curves_${asof}_1830.revised");
while ($line = <CURVE_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^issuerName\|issuerShortCode/)
 {next;}
 ($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
 $curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
 $snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
 $curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

 if ($curveStatus ne "ok") {next;}

 if ($curveSource ne "pc" && $curveExternalName ne "NULL") {
 $prc_curve_id = $pc_map_list->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType};
 $src_name_to_pc_id->{$curveSource}->{$curveExternalName} = $prc_curve_id;
 }
}
close(CURVE_FILE);

open(LEVEL_FILE, "< GCDR.levels_${asof}_1830.roll");
while ($line = <LEVEL_FILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^curve_id\|roll/)
 {next;}
 ($curve_id, $roll, $type, $tag, $roll_date, $date, $maturity, $maturity_string, $bid, $ask, $entered_date, $entered_user) = split (/\s*\|\s*|\|/, $line);

 if ($type eq "close" && $tag eq "") {
 $last_close_date->{$curve_id} = $date;
 $last_close_user->{$curve_id} = $entered_user;

 #AP - load mid levels
 $gcdr_levels->{$curve_id}->{$tennor_map->{$maturity_string}} = ($bid + $ask)/2;
 #print "$curve_id|$tennor_map->{$maturity_string}|$gcdr_levels->{$curve_id}->{$tennor_map->{$maturity_string}}\n";
 }
}
close(LEVEL_FILE);

open (PCFILE, "< pc_file_$asof.txt");
while ($line = <PCFILE>)
{
 chomp($line);

 # remove heading etc
 if ($line =~ /curve_id\b|^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}

 ($dummy,
 $prc_curve_id,
 $prc_source,
 $prc_ref_id
 ) = split (/\s*\|\s*|\|/, $line);

 $pc_source_map->{$prc_curve_id} = $prc_source;
 $pc_ref_id_map->{$prc_curve_id} = $prc_ref_id;
}
close (PCFILE);

open(PT_FILE, "< curves.csv_$asof");
while (<PT_FILE>) {
chomp;
($creditRiskId,
 $issuerId,
 $curveId,
 $issuerNameAndSubord,
 $date,
 $currency,
 $frequency,
 $daycount,
 $calendar,
 $rollingConvention,
 $industry,
 $recovery,
 $accrue,
 $numPoints,
 @levels) = split /,/;

$recovery *= 100.0 if $recovery != 0;

# if (defined($recovery)) {
 $pt_recovery_list->{$curveId}->{$recovery} = $curveId;
# }

$prc_ticker = $issuer_map->{$curveId}->{ticker};
$prc_subord = $issuer_map->{$curveId}->{subord};
$pt_rating_list->{$prc_ticker}->{$prc_subord}->{"//"} = $curveId;

for ($i = 0; $i < $numPoints; $i++) {
 $t_str = $levels[2 * $i];
 $l = $levels[2 * $i + 1];
 if ($t_str =~ /(\d+)Y\b/) {
 $t = $1 . ".000000";
 $pt_level_list->{$curveId}->{$t} = $l;
 } elsif ($t_str =~ /(\d+)M\b/) {
 $t = sprintf("%8.6f", $1 / 12.0);
 $pt_level_list->{$curveId}->{$t} = $l;
 }
}
}
close(PT_FILE);

@storm_trade_files = `ls mkt_tmapp_NY_STORM.*$asof*`;
foreach $storm_trade_file (@storm_trade_files) {
$storm_db = "";
open(STORM_TRADE_FILE, "< $storm_trade_file");
while ($line = <STORM_TRADE_FILE>) {
 if ($line =~ /^#/) {
 if ($line =~ /\|DATABASE=(\w+)\|/) {
 $storm_db = $1;
 }
 } else {
 chomp($line);

 ($storm_trade_id,
 $oasys_id,
 $type,
 $description,
 $curve) = split (/\|/, $line);

 $storm_active_list->{"$storm_db/$curve"}->{$type} += 1;
 }
}
close(STORM_TRADE_FILE);
}

open(GK_FILE, "< gk_curve_$asof.txt");
while (<GK_FILE>) {
chomp;
@fields = split /\s*\|\s*|\|/;
if ($fields[4] =~ /^Z/ && $fields[25] =~ /Default Swap/ && defined($fields[22]) && $fields[20] ne "") {
 $gk_curve = "$fields[7]/$fields[20]";
 $gk_recovery = $fields[22];
 $prc_curve_id = $src_name_to_pc_id->{"gk"}->{$gk_curve};
 if (defined($prc_curve_id)) {
 $gk_recovery_list->{$prc_curve_id}->{$gk_recovery} = $gk_curve;
 } else {
 # Unmapped GK curve
 }
}
}
close(GK_FILE);

open (STORM_FILE, "< storm_curves_$asof.txt");
while ($line = <STORM_FILE>)
{
 chomp($line);

 # remove heading etc
 if ($line =~ /source\b|^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 ($dummy,
 $storm_db,
 $storm_curve,
 $storm_recovery,
 $storm_mdy,
 $storm_snp) = split (/\s*\|\s*|\|/, $line);

 $storm_recovery = "" if $storm_recovery eq "NULL";
 # Rating
 ##$storm_mdy = "-" if $storm_mdy =~ /^N|^\s*$/;
 ##$storm_snp = "-" if $storm_snp =~ /^N|^\s*$/;
 $storm_mdy = "-" if $storm_mdy =~ /^NotRa|^\s*$/;
 $storm_snp = "-" if $storm_snp =~ /^NotRa|^\s*$/;
 $prc_curve_id = $src_name_to_pc_id->{"storm"}->{$storm_curve};
 $prc_ticker = $src_name_to_ticker->{"storm"}->{$storm_curve};
 $prc_subord = $src_name_to_subord->{"storm"}->{$storm_curve};

 if (defined($storm_active_list->{"$storm_db/$storm_curve"})) {
 $storm_recovery_list->{$prc_curve_id}->{$storm_recovery} = "$storm_db/$storm_curve";
 $storm_rating_list->{$prc_ticker}->{$prc_subord}->{"$storm_snp/$storm_mdy/"} = "$storm_db/$storm_curve";
 }

 $all_storm_recovery_list->{$storm_curve}->{$storm_db} = $storm_recovery;
 $all_storm_db_list->{$storm_db} = 1;
}
close(STORM_FILE);

open (MARKIT_FILE, "< markit_file_$asof.txt");

while ($line = <MARKIT_FILE>)
{
 chomp($line);

 # remove heading etc
 if ($line =~ /instrument_id\b|^(-|\s|\|)*$|^$.*rows affected$$|^$return status =.*$$/)
 {next;}
 ($dummy,
 $markit_curve,
 $markit_recovery,
 $prc_curve_id,
 $markit_composite) = split (/\s*\|\s*|\|/, $line);

 $markit_recovery = "" if $markit_recovery eq "NULL";
 $markit_curve = "" if $markit_curve eq "NULL";

 $markit_composite = "" if $markit_composite eq "NULL";
 $markit_composite *= 100.0 if $markit_composite != 0;

 $markit_recovery_list->{$prc_curve_id}->{$markit_recovery} = $markit_curve;
 $markit_comp_list->{$prc_curve_id}->{$markit_recovery} = $markit_composite;
}
close(MARKIT_FILE);

@emct_trade_files = `ls EMCT.*.$asof`;

foreach $emct_file (@emct_trade_files) {
read_emct_file($emct_file);
}

$emct_recovery_list = &read_calypso_curve_file("EMCTCurveRecoveryRate_${asof}.txt", $emct_curve_list);

@calypso_trade_files = `ls solarfeed.*.$asof`;

foreach $calypso_file (@calypso_trade_files) {
read_calypso_file($calypso_file);
}

$ca_recovery_list = &read_calypso_curve_file("FlowCurveRecoveryRate_${asof}.txt", $ca_curve_list);

open (CFILE, "< GCDR.curves_${asof}_1830.revised");
open (UFILE, "> pc_usage.csv");
open (UMAP_FILE, "> calypso_umapped.txt");
open (EUMAP_FILE, "> emct_umapped.txt");
while ($line = <CFILE>)
{
 chomp($line);
 # remove heading etc
 if ($line =~ /^issuerName\|issuerShortCode/)
 {next;}
 ($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
 $curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
 $snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
 $curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

 if ($curveStatus ne "ok") {next;}

 if ($curveSource eq "pc") {
 #print "Processing PC ".$curveId;
 process_recovery($curveId, $issuerId, $issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveType, $curveRecovery)
 }
}

close (CFILE);
close (UFILE);

foreach $emct_curve (sort keys %$emct_cr01_list) {
print EUMAP_FILE "$emct_curve,$emct_cr01_list->{$emct_curve}\n";
}
close (EUMAP_FILE);

foreach $ca_curve (sort keys %$ca_cr01_list) {
print UMAP_FILE "$ca_curve,$ca_cr01_list->{$ca_curve}\n";
}
close (UMAP_FILE);

@all_storm_db = sort keys %$all_storm_db_list;

open(OFILE, "> recovery_recon.${asof}.xls");
open(OSFILE, "> storm_recon.${asof}.xls");

print OFILE <<EOF;
<html>
<head>
<title>Recovery Recon Report</title>
</head>
<body>
Report Date: $asof
EOF

print OSFILE <<EOF;
<html>
<head>
<title>Storm Recon Report</title>
</head>
<body>
Report Date: $asof
<table border="1" cellpadding="0" cellspacing="0">
<tr>
 <td bgcolor="$light_yellow">Action</td>
 <td bgcolor="$light_yellow">Owner</td>
 <td bgcolor="$light_yellow">Marx Ticker</td>
 <td bgcolor="$light_yellow">Marx Issuer Name</td>
 <td bgcolor="$light_yellow">CCY</td>
 <td bgcolor="$light_yellow">Subord</td>
 <td bgcolor="$light_yellow">Doc Clause</td>
 <td bgcolor="$light_yellow">Type</td>
 <td bgcolor="$light_yellow">Pricing Source</td>
 <td bgcolor="$light_yellow">Pricing Curve ID</td>
 <td bgcolor="$light_yellow">Marx Recovery</td>
 <td bgcolor="$light_yellow">Storm Curve</td>
EOF

foreach $storm_db (@all_storm_db) {
print OSFILE <<EOF;
 <td bgcolor="$light_yellow">$storm_db</td>
EOF
}

print OSFILE " </tr>\n";

open(SUM_FILE, "> summary_$asof.txt");

print_recovery_report("Recovery Rate Reconciliation Report", \@recovery_recon_report, 0);

print_mismatch_summary("Recovery Rate Reconciliation Report");

print_recovery_report("Zero Recovery in Marx", \@zero_report, 1);

print_recovery_report("Senior Unsecured Recovery not Valid in Marx", \@senior_not_40_report, 1);

print_recovery_report("Subordinated Recovery not Valid in Marx", \@sub_not_25_report, 1);

print_excluded_report(\@recovery_excluded_report, "recovery");

close(SUM_FILE);

print OFILE <<EOF;
</body>
</html>
EOF

print OSFILE <<EOF;
</table>
</body>
</html>
EOF

close (OFILE);
close (OSFILE);

open(SUM_FILE, "> stale_summary_$asof.txt");
print_stale_report(\@stale_report);

print_excluded_report(\@stale_excluded_report, "stale");
close(SUM_FILE);

print_prod_cntrl_report(\@stale_report_prod_ctrl);

open (RFILE, "< GCDR.issuer_ratings.data.$asof");
while ($line = <RFILE>) {
chomp($line);
if ($line =~ /^issuer_id\|ticker/)
 {next;}

($issuer_id, $ticker, $name, $equity_ticker, $red, $country, $region, $industry, $sub, $subord, $mdy_rating, $snp_rating, $rni_rating, $fch_rating,
 $mdy_watch, $snp_watch, $rni_watch, $fch_watch, $issuer_type) = split (/\s*\|\s*|\|/, $line);

process_rating($ticker, $name, $equity_ticker, $red, $sub, $subord, $snp_rating, $mdy_rating, $fch_rating);
}
close(RFILE);

open(SUM_FILE, "> rating_summary_$asof.txt");

open(SFILE, "> rating_recon.${asof}.xls");
print SFILE <<EOF;
<html>
<head>
<title>Issuer Rating Report</title>
</head>
<body>
Report Date: $asof
EOF
###print_rating_report("Issuer Rating Recon Report", \@rating_report);
print_rating_report("Missing rating everywhere", \@blank_rating_report2);
print_rating_report("Missing rating in Marx but present in another", \@blank_rating_report1);
print_rating_report("Rating Mismatch", \@rating_report);
print SFILE <<EOF;
</body>
</html>
EOF
close (SFILE);
print_rating_excluded_report(\@rating_excluded_report, "rating");
close(SUM_FILE);

###########################################################################

sub read_emct_file() {
my($fname) = @_;

open(EMCT_FILE, "< $fname") or return;

while (<EMCT_FILE>) {
 @fields = split /\|/;
 if ($fields[0] !~ /^\*/) {
 $ops_file = $fields[4];
 $firm_acct = $fields[10];
 $trade_type = $fields[11];
 $ticker = $fields[17];
 $subord = $fields[18];
 $snp= $fields[19];
 $mdy = $fields[20];
 $fch= $fields[21];
 $term_date = $fields[23];
 $emct_curve = $fields[42];
 $emct_recovery = $fields[43];
 $ccy = $fields[45];
 $cr01 = $fields[76];
 $dv01 = $fields[77];
 $rr01 = $fields[80];

 if ($emct_curve ne "") {
$emct_cr01_list->{"$emct_curve,$firm_acct"} += $cr01;
$emct_rr01_list->{"$emct_curve,$firm_acct"} += $rr01;
 } elsif ($cr01 != 0.0) {
# print "No Curve: $ticker, $cr01\n";
 }

 if ($trade_type eq "CreditDefaultSwap" && $term_date eq "" &&
 $emct_curve =~ /^(\S+)-pc-(.+)$/) {
 @tail = split /-/, $emct_curve;
 $prc_curve_id = $tail[-1];
 if ($prc_curve_id ne "") {
 #$curve_recovery = $emct_curve_recovery_list->{$prc_curve_id};
 #if (!defined($curve_recovery)) {
 # $curve_recovery = $emct_recovery;
 #}
 #$emct_recovery_list->{$prc_curve_id}->{$curve_recovery} = $emct_curve;
 $emct_curve_list->{$prc_curve_id} = $emct_curve;

 # Rating
 #$mdy = "-" if $mdy =~ /^N|^W|^\s*$/;
 #$snp = "-" if $snp =~ /^N|^W|^\s*$/;
 #$fch = "-" if $fch =~ /^N|^W|^\s*$/;
 $emct_rating_list->{$ticker}->{$emct_subord_map->{$subord}}->{"$snp/$mdy/$fch"} = $emct_curve;

 }
 }
 }
}
close(EMCT_FILE);
}

sub read_calypso_file() {
my($fname) = @_;

open(CA_FILE, "< $fname") or return;

while (<CA_FILE>) {
 @fields = split /\|/;
 if ($fields[0] !~ /^\*/) {
 $ops_file = $fields[4];
 $firm_acct = $fields[10];
 $trade_type = $fields[11];
 $ticker = $fields[17];
 $subord = $fields[18];
 $snp= $fields[19];
 $mdy = $fields[20];
 $fch= $fields[21];
 $term_date = $fields[23];
 $ca_curve = $fields[42];
 $ca_recovery = $fields[43];
 $ccy = $fields[45];
 $cr01 = $fields[76];
 $dv01 = $fields[77];
 $rr01 = $fields[80];

 if ($ca_curve ne "") {
$ca_cr01_list->{"$ca_curve,$firm_acct"} += $cr01;
$ca_rr01_list->{"$ca_curve,$firm_acct"} += $rr01;
 } elsif ($cr01 != 0.0) {
# print "No Curve: $ticker, $cr01\n";
 }

 if ($trade_type eq "CreditDefaultSwap" && $term_date eq "" &&
 $ca_curve =~ /^(\S+)-pc-(.+)$/) {
 # AMCOR-pc-USD-SEN-MR-19965
 # 03072STM7-pc-USD-SEN-mbs-64213
 # 437084CE4-pc-USD-SEN-mbs-NA-71570
 @tail = split /-/, $ca_curve;
 $prc_curve_id = $tail[-1];
 if ($prc_curve_id ne "") {
 #$curve_recovery = $ca_curve_recovery_list->{$prc_curve_id};
 #if (!defined($curve_recovery)) {
 # $curve_recovery = $ca_recovery;
 #}
 #$ca_recovery_list->{$prc_curve_id}->{$curve_recovery} = $ca_curve;
 $ca_curve_list->{$prc_curve_id} = $ca_curve;

 # Rating
 #$mdy = "-" if $mdy =~ /^N|^W|^\s*$/;
 #$snp = "-" if $snp =~ /^N|^W|^\s*$/;
 #$fch = "-" if $fch =~ /^N|^W|^\s*$/;
 $ca_rating_list->{$ticker}->{$ca_subord_map->{$subord}}->{"$snp/$mdy/$fch"} = $ca_curve;

 }
 }
 }
}
close(CA_FILE);
}

sub read_calypso_curve_file() {
my($fname, $curve_list) = @_;
my($curve_recovery_list) = {};

open(CA_FILE, "< $fname") or return;

while ($line = <CA_FILE>) {
 chomp($line);
 if ($line =~ /^ticker_name\|/)
 {next;}
 my ($ca_curve, $ca_recovery) = split(/\|/, $line);
 if ($ca_curve =~ /^(\S+)-pc-(.+)$/) {
 # AMCOR-pc-USD-SEN-MR-19965
 # 03072STM7-pc-USD-SEN-mbs-64213
 # 437084CE4-pc-USD-SEN-mbs-NA-71570
 @tail = split /-/, $ca_curve;
 $prc_curve_id = $tail[-1];
 if ($prc_curve_id ne "") {
 $ca_curve = $curve_list->{$prc_curve_id};
 if (defined($ca_curve)) {
 $curve_recovery = $ca_recovery*100.0;
 $curve_recovery_list->{$prc_curve_id}->{$curve_recovery} = $ca_curve;
 }
 }
 }
}
close(CA_FILE);
return $curve_recovery_list;
}

sub print_recovery_report() {
my($rpt_title, $rpt, $print_sector_summary) = @_;

$num_curves = scalar @$rpt;

print OFILE <<EOF;
$rpt_title ($num_curves curves)
<table border="1" cellpadding="0" cellspacing="0">
<tr>
 <td bgcolor="$light_yellow">Action</td>
 <td bgcolor="$light_yellow">Owner</td>
 <td bgcolor="$light_yellow">Marx Ticker</td>
 <td bgcolor="$light_yellow">Marx Issuer Name</td>
 <td bgcolor="$light_yellow">CCY</td>
 <td bgcolor="$light_yellow">Subord</td>
 <td bgcolor="$light_yellow">Doc Clause</td>
 <td bgcolor="$light_yellow">Type</td>
 <td bgcolor="$light_yellow">Pricing Source</td>
 <td bgcolor="$light_yellow">Pricing Curve ID</td>
 <td bgcolor="$light_yellow">Last Close Date</td>
 <td bgcolor="$light_yellow">Username</td>
 <td bgcolor="$light_yellow">Marx Recovery</td>
 <td bgcolor="$light_yellow">Mark-It Name</td>
 <td bgcolor="$light_yellow">Mark-It Composite</td>
 <td bgcolor="$light_yellow">Mark-It Recovery</td>
 <td bgcolor="$light_yellow">EMCT Name</td>
 <td bgcolor="$light_yellow">EMCT Recovery</td>
 <td bgcolor="$light_yellow">Calypso Name</td>
 <td bgcolor="$light_yellow">Calypso Recovery</td>
 <td bgcolor="$light_yellow">PT Recovery</td>
 <td bgcolor="$light_yellow">Storm Name</td>
 <td bgcolor="$light_yellow">Storm Recovery</td>
 <td bgcolor="$light_yellow">GK Name</td>
 <td bgcolor="$light_yellow">GK Recovery</td>
</tr>
EOF

my($sector_summary) = {};

foreach $rec (sort {$a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

 $desk = &get_summary_desk($rec->{prc_sector});
 $sector_summary->{$desk} += 1;

 print OFILE <<EOF;
<tr>
 <td>$rec->{prc_action}</td>
 <td>$rec->{prc_sector}</td>
 <td>$rec->{prc_ticker}</td>
 <td>$rec->{prc_iname}</td>
 <td>$rec->{prc_currency}</td>
 <td>$rec->{prc_subord}</td>
 <td>$rec->{prc_doc_id}</td>
 <td>$rec->{prc_type}</td>
 <td>$rec->{prc_source}</td>
 <td>$rec->{prc_curve_id}</td>
 <td>$rec->{prc_last_date}</td>
 <td>$rec->{prc_last_user}</td>
 <td $rec->{prc_color}>$rec->{prc_recovery}</td>
 <td>$rec->{markit_id}</td>
 <td>$rec->{markit_comp}</td>
 <td $rec->{markit_color}>$rec->{markit_recovery}</td>
 <td>$rec->{emct_id}</td>
 <td $rec->{emct_color}>$rec->{emct_recovery}</td>
 <td>$rec->{ca_id}</td>
 <td $rec->{ca_color}>$rec->{ca_recovery}</td>
 <td $rec->{pt_color}>$rec->{pt_recovery}</td>
 <td>$rec->{storm_id}</td>
 <td $rec->{storm_color}>$rec->{storm_recovery}</td>
 <td>$rec->{gk_id}</td>
 <td $rec->{gk_color}>$rec->{gk_recovery}</td>
</tr>
EOF
 if ($rec->{storm_id} ne "" || $rec->{prc_source} eq "storm") {
 if ($rec->{storm_id} eq "" && $rec->{prc_source} eq "storm") {
 $storm_curve = $src_id_to_name->{$rec->{prc_ref_id}}
 } else {
 $storm_curve = $rec->{storm_id};
 $storm_curve =~ s/^.*\///;
 }

 print OSFILE <<EOF;
<tr>
 <td>$rec->{prc_action}</td>
 <td>$rec->{prc_sector}</td>
 <td>$rec->{prc_ticker}</td>
 <td>$rec->{prc_iname}</td>
 <td>$rec->{prc_currency}</td>
 <td>$rec->{prc_subord}</td>
 <td>$rec->{prc_doc_id}</td>
 <td>$rec->{prc_type}</td>
 <td>$rec->{prc_source}</td>
 <td>$rec->{prc_curve_id}</td>
 <td $rec->{prc_color}>$rec->{prc_recovery}</td>
 <td>$storm_curve</td>
EOF

 foreach $storm_db (@all_storm_db) {
 $storm_recovery = $all_storm_recovery_list->{$storm_curve}->{$storm_db};
 $storm_color = (defined($storm_recovery) && $storm_recovery != $rec->{prc_recovery})?"bgcolor=\"$light_red\"":"";
 print OSFILE <<EOF;
 <td $storm_color>$storm_recovery</td>
EOF
 }

 print OSFILE " </tr>\n";
 }
}
print OFILE <<EOF;
</table>
EOF

if ($print_sector_summary) {
 print SUM_FILE "$rpt_title\n\n";
 if (keys %$sector_summary > 0) {
 foreach $desk (sort keys %$sector_summary) {
$n_mismatch = $sector_summary->{$desk};
print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
 }
 } else {
 print SUM_FILE sprintf "\t%35s\n", ("None");
 }
 print SUM_FILE "\n";
}
}

sub process_recovery() {
my($prc_curve_id, $prc_issuer_id, $prc_iname, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id, $prc_recovery) = @_;
#print join('|', "Processing ", $prc_curve_id, $prc_issuer_id, $prc_iname, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id, $prc_recovery);
$prc_source = $pc_source_map->{$prc_curve_id};
$prc_ref_id = $pc_ref_id_map->{$prc_curve_id};

#AP
$prc_owner_id = $blotter_id_sector_map->{$prc_ref_id};
$prc_sector = $desk_map->{$prc_owner_id};

$prc_subord = $subord_map->{$prc_subord_id};
$prc_type = $curve_type_map->{$prc_type_id};

$prc_recovery = 0.0 if $prc_recovery eq "NULL";

# $prc_last_date = $last_close_date->{$prc_curve_id};
$summary_desk = &get_summary_desk($prc_sector);
$prc_last_date = $last_close_date->{$prc_curve_id};
$prc_last_date_prod_ctrl = $prc_last_date;
$prc_last_change_date = $last_change_date->{$prc_curve_id};
$prc_use_level_change = "";
$prc_use_level_change_prod_ctrl = "";

$consecutive_days_closed_same = "";

if (defined($excluded_list->{"level_change"}->{$summary_desk}) && defined($prc_last_change_date) && $prc_last_change_date < $prc_last_date) {
 $prc_last_date = $prc_last_change_date;
 $prc_use_level_change = "Yes";
}

if (defined($excluded_list->{"level_change_prod_ctrl"}->{$summary_desk}) && defined($prc_last_change_date) && $prc_last_change_date < $prc_last_date_prod_ctrl) {
 $consecutive_days_closed_same = &diff_dates($asof, $prc_last_change_date);
 $prc_last_date_prod_ctrl = $prc_last_change_date;
 $prc_use_level_change_prod_ctrl = "Yes";
}

$prc_last_date = "" if $prc_last_date eq "NULL";
$prc_last_date_prod_ctrl = "" if $prc_last_date_prod_ctrl eq "NULL";

$prc_last_user = $last_close_user->{$prc_curve_id};
if (defined($username_map->{$prc_last_user})) {
 $prc_last_user = $username_map->{$prc_last_user};
}

my($markit_recovery, $markit_id, $markit_comp, $markit_mismatch, $markit_color);
my($pt_recovery, $pt_id, $pt_mismatch, $pt_color);
my($gk_recovery, $gk_id, $gk_mismatch, $gk_color);
my($emct_recovery, $emct_id, $emct_mismatch, $emct_color);
my($ca_recovery, $ca_id, $ca_mismatch, $ca_color);
my($storm_recovery, $storm_id, $storm_mismatch, $storm_color);

$nn = 0;

@markit_rates = sort keys %{$markit_recovery_list->{$prc_curve_id}};
$n_markit = @markit_rates;
# $nn = $n_markit if $nn < $n_markit;

@pt_rates = sort keys %{$pt_recovery_list->{$prc_curve_id}};
$n_pt = @pt_rates;
$nn = $n_pt if $nn < $n_pt;

@gk_rates = sort keys %{$gk_recovery_list->{$prc_curve_id}};
$n_gk = @gk_rates;
$nn = $n_gk if $nn < $n_gk;

@emct_rates = sort keys %{$emct_recovery_list->{$prc_curve_id}};
$n_emct = @emct_rates;
if ($n_emct > 1) {
my($ok) = 0;

foreach $emct_rate (@emct_rates) {
if ($emct_rate == $prc_recovery) {
$ok = 1;
break;
}
}
if ($ok) {
@emct_rates = ($prc_recovery);
$n_emct = @emct_rates;
}
}
$nn = $n_emct if $nn < $n_emct;

if ($emct_curve_list->{$prc_curve_id} && $n_emct == 0) {
 $emct_subord = uc $prc_subord_id;
 if ($prc_type_id eq "cds") {
 print EUMAP_FILE "$prc_ticker-pc-$prc_currency-$emct_subord-$prc_curve_id\t$emct_curve_list->{$prc_curve_id}\n";
 } else {
 print EUMAP_FILE "$prc_ticker-pc-$prc_currency-$emct_subord-$prc_type_id-$prc_curve_id\t$emct_curve_list->{$prc_curve_id}\n";
 }
}

@ca_rates = sort keys %{$ca_recovery_list->{$prc_curve_id}};
$n_ca = @ca_rates;
if ($n_ca > 1) {
my($ok) = 0;

foreach $ca_rate (@ca_rates) {
if ($ca_rate == $prc_recovery) {
$ok = 1;
break;
}
}
if ($ok) {
@ca_rates = ($prc_recovery);
$n_ca = @ca_rates;
}
}
$nn = $n_ca if $nn < $n_ca;

if ($ca_curve_list->{$prc_curve_id} && $n_ca == 0) {
 $ca_subord = uc $prc_subord_id;
 if ($prc_type_id eq "cds") {
 print UMAP_FILE "$prc_ticker-pc-$prc_currency-$ca_subord-$prc_curve_id\t$ca_curve_list->{$prc_curve_id}\n";
 } else {
 print UMAP_FILE "$prc_ticker-pc-$prc_currency-$ca_subord-$prc_type_id-$prc_curve_id\t$ca_curve_list->{$prc_curve_id}\n";
 }
}

@storm_rates = sort keys %{$storm_recovery_list->{$prc_curve_id}};
$n_storm = @storm_rates;
$nn = $n_storm if $nn < $n_storm;

$prc_senior_not_40 = 0;
$prc_sub_not_25 = 0;
$action = "";

$standard_recovery = &get_standard_recovery($prc_sector, $prc_subord, $prc_ticker, $prc_iname, "HI");
$standard_recovery_lo = &get_standard_recovery($prc_sector, $prc_subord, $prc_ticker, $prc_iname, "LO");

$prc_is_zero = (! &allow_zero_recovery($prc_sector) && $prc_recovery == 0 && $standard_recovery != 0);

if ($prc_is_zero) {
 $action = &get_action($prc_source, $prc_sector, $standard_recovery, $standard_recovery_lo);
}

if ($prc_source eq "gk") {
 # should not use GK
 if ($prc_subord =~ /^Senior Unsecured/) {
 $prc_senior_not_40 = 1;
 } else {
 $prc_sub_not_25 = 1;
 }
 $action = &get_action($prc_source, "", $standard_recovery, $standard_recovery_lo);
}

$prc_mismatch = ($prc_is_zero || $prc_senior_not_40 || $prc_sub_not_25);
$prc_color = $prc_mismatch?"bgcolor=\"$light_red\"":"";

for ($i = 0; $i < $nn; $i++) {

 if ($i < $n_markit) {
 $markit_recovery = $markit_rates[$i];
 $markit_id = $markit_recovery_list->{$prc_curve_id}->{$markit_recovery};
 $markit_comp = $markit_comp_list->{$prc_curve_id}->{$markit_recovery};

 $markit_mismatch = $markit_recovery ne "" && abs($prc_recovery - $markit_recovery) >= 1.0;
 $markit_color = $markit_mismatch?"bgcolor=\"$light_red\"":"";
 }

 if ($i < $n_pt) {
 $pt_recovery = $pt_rates[$i];
 $pt_id = $pt_recovery_list->{$prc_curve_id}->{$pt_recovery};
 $pt_mismatch = defined($pt_recovery) && (abs($prc_recovery - $pt_recovery) >= 1.0);
 $pt_color = $pt_mismatch?"bgcolor=\"$light_red\"":"";
 }

 if ($i < $n_gk) {
 $gk_recovery = $gk_rates[$i];
 $gk_id = $gk_recovery_list->{$prc_curve_id}->{$gk_recovery};
 $gk_mismatch = defined($gk_recovery) && (abs($prc_recovery - $gk_recovery) >= 1.0);
 $gk_color = $gk_mismatch?"bgcolor=\"$light_red\"":"";
 }

if ($i < $n_emct) {
 $emct_recovery = $emct_rates[$i];
 $emct_id = $emct_recovery_list->{$prc_curve_id}->{$emct_recovery};
 $emct_mismatch = defined($emct_recovery) && (abs($prc_recovery - $emct_recovery) >= 1.0);
 $emct_color = $emct_mismatch?"bgcolor=\"$light_red\"":"";
 }

 if ($i < $n_ca) {
 $ca_recovery = $ca_rates[$i];
 $ca_id = $ca_recovery_list->{$prc_curve_id}->{$ca_recovery};
 $ca_mismatch = defined($ca_recovery) && (abs($prc_recovery - $ca_recovery) >= 1.0);
 $ca_color = $ca_mismatch?"bgcolor=\"$light_red\"":"";
 }

 if ($i < $n_storm) {
 $storm_recovery = $storm_rates[$i];
 $storm_id = $storm_recovery_list->{$prc_curve_id}->{$storm_recovery};
 $storm_mismatch = defined($storm_recovery) && (abs($prc_recovery - $storm_recovery) >= 1.0);
 $storm_color = $storm_mismatch?"bgcolor=\"$light_red\"":"";
 }

 if ($i == 0) {
 print UFILE join(',', $prc_curve_id, $prc_ticker,
 $prc_currency, $prc_subord, $prc_type, $prc_recovery,
 $prc_source, "\"$prc_sector\"", $prc_last_date, $emct_id, $ca_id, $pt_id, $storm_id, $gk_id, "\n");
 }

#AP
#$markit_level = $gcdr_levels->{$markit_id} #will only work if we add the markit curve_id in the query in runReconRpt.ksh, line 93

$markit_curve_id = $gcdr_curves->{$prc_ticker}->{$prc_currency}->{$prc_subord_id}->{$prc_doc_id}->{$prc_type_id}->{"markit"};
# print join('|', "PC Details", $prc_curve_id, $prc_source, $prc_ref_id);
# print join('|', "Found Markit Curve", $markit_curve_id, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id);

#for all in tennor_map
$markit_level_3M = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"3M"}} : "";
$markit_level_6M = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"6M"}} : "";
$markit_level_1Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"1Y"}} : "";
$markit_level_2Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"2Y"}} : "";
$markit_level_3Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"3Y"}} : "";
$markit_level_4Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"4Y"}} : "";
$markit_level_5Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"5Y"}} : "";
$markit_level_7Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"7Y"}} : "";
$markit_level_10Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"10Y"}} : "";
$markit_level_15Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"15Y"}} : "";
$markit_level_20Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"20Y"}} : "";
$markit_level_30Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"30Y"}} : "";

$prc_level_3M= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"3M"}};
$prc_level_6M= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"6M"}};
$prc_level_1Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"1Y"}};
$prc_level_2Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"2Y"}};
$prc_level_3Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"3Y"}};
$prc_level_4Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"4Y"}};
$prc_level_5Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"5Y"}};
$prc_level_7Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"7Y"}};
$prc_level_10Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"10Y"}};
$prc_level_15Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"15Y"}};
$prc_level_20Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"20Y"}};
$prc_level_30Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"30Y"}};

# print "$prc_curve_id|$prc_ticker|$prc_currency|$prc_subord_id|$prc_type_id|$prc_level_5Y|$markit_curve_id|$markit_level_5Y\n";
# print "$markit_curve_id|$tennor_map->{\"5Y\"}|$gcdr_levels->{$markit_curve_id}->{$tennor_map->{\"5Y\"}}\n";
# print "$prc_curve_id|$tennor_map->{\"5Y\"}|$gcdr_levels->{$prc_curve_id}->{$tennor_map->{\"5Y\"}}\n";

 my($rec) = {};
 $rec->{prc_action} = $action;
 $rec->{prc_sector} = $prc_sector;
 $rec->{prc_ticker} = $prc_ticker;
 $rec->{prc_iname} = $prc_iname;
 $rec->{prc_currency} = $prc_currency;
 $rec->{prc_subord} = $prc_subord;
 $rec->{prc_doc_id} = $prc_doc_id;
 $rec->{prc_type} = $prc_type;
 $rec->{prc_source} = $prc_source;
 $rec->{prc_curve_id} = $prc_curve_id;
 $rec->{prc_ref_id} = $prc_ref_id;
 $rec->{prc_color} = $prc_color;
 $rec->{prc_recovery} = $prc_recovery;
 $rec->{prc_last_date} = $prc_last_date;
 $rec->{prc_last_date_prod_ctrl} = $prc_last_date_prod_ctrl;
 $rec->{consecutive_days_closed_same} = $consecutive_days_closed_same;
 $rec->{prc_use_level_change} = $prc_use_level_change;
 $rec->{prc_use_level_change_prod_ctrl} = $prc_use_level_change_prod_ctrl;
 $rec->{prc_last_user} = $prc_last_user;
 $rec->{markit_id} = $markit_id;
 $rec->{markit_curve_id} = $markit_curve_id;
 $rec->{markit_comp} = $markit_comp;

 #AP
 $rec->{prc_level_3M} = $prc_level_3M;
 $rec->{prc_level_6M} = $prc_level_6M;
 $rec->{prc_level_1Y} = $prc_level_1Y;
 $rec->{prc_level_2Y} = $prc_level_2Y;
 $rec->{prc_level_3Y} = $prc_level_3Y;
 $rec->{prc_level_4Y} = $prc_level_4Y;
 $rec->{prc_level_5Y} = $prc_level_5Y;
 $rec->{prc_level_7Y} = $prc_level_7Y;
 $rec->{prc_level_10Y} = $prc_level_10Y;
 $rec->{prc_level_15Y} = $prc_level_15Y;
 $rec->{prc_level_20Y} = $prc_level_20Y;
 $rec->{prc_level_30Y} = $prc_level_30Y;

 $rec->{markit_level_3M} = $markit_level_3M;
 $rec->{markit_level_6M} = $markit_level_6M;
 $rec->{markit_level_1Y} = $markit_level_1Y;
 $rec->{markit_level_2Y} = $markit_level_2Y;
 $rec->{markit_level_3Y} = $markit_level_3Y;
 $rec->{markit_level_4Y} = $markit_level_4Y;
 $rec->{markit_level_5Y} = $markit_level_5Y;
 $rec->{markit_level_7Y} = $markit_level_7Y;
 $rec->{markit_level_10Y} = $markit_level_10Y;
 $rec->{markit_level_15Y} = $markit_level_15Y;
 $rec->{markit_level_20Y} = $markit_level_20Y;
 $rec->{markit_level_30Y} = $markit_level_30Y;

 $rec->{diff_level_3M} = $prc_level_3M-$markit_level_3M;
 $rec->{diff_level_6M} = $prc_level_6M-$markit_level_6M;
 $rec->{diff_level_1Y} = $prc_level_1Y-$markit_level_1Y;
 $rec->{diff_level_2Y} = $prc_level_2Y-$markit_level_2Y;
 $rec->{diff_level_3Y} = $prc_level_3Y-$markit_level_3Y;
 $rec->{diff_level_4Y} = $prc_level_4Y-$markit_level_4Y;
 $rec->{diff_level_5Y} = $prc_level_5Y-$markit_level_5Y;
 $rec->{diff_level_7Y} = $prc_level_7Y-$markit_level_7Y;
 $rec->{diff_level_10Y} = $prc_level_10Y-$markit_level_10Y;
 $rec->{diff_level_15Y} = $prc_level_15Y-$markit_level_15Y;
 $rec->{diff_level_20Y} = $prc_level_20Y-$markit_level_20Y;
 $rec->{diff_level_30Y} = $prc_level_30Y-$markit_level_30Y;

 $rec->{markit_color} = $markit_color;
 $rec->{markit_recovery} = $markit_recovery;
 $rec->{pt_id} = $pt_id;
 $rec->{pt_color} = $pt_color;
 $rec->{pt_recovery} = $pt_recovery;
 $rec->{gk_id} = $gk_id;
 $rec->{gk_color} = $gk_color;
 $rec->{gk_recovery} = $gk_recovery;
 $rec->{emct_id} = $emct_id;
 $rec->{emct_color} = $emct_color;
 $rec->{emct_recovery} = $emct_recovery;
 $rec->{ca_id} = $ca_id;
 $rec->{ca_color} = $ca_color;
 $rec->{ca_recovery} = $ca_recovery;
 $rec->{storm_id} = $storm_id;
 $rec->{storm_color} = $storm_color;
 $rec->{storm_recovery} = $storm_recovery;

 $rec->{workdays_stale} = 1;

 $stale_excluded = &excluded_stale($rec);
 $no_standard = &no_standard($rec);

if ($no_standard) {
$rec->{excluded} = $no_standard;
push(@recovery_excluded_report, $rec);
 } elsif ($prc_is_zero || $prc_senior_not_40 || $prc_sub_not_25) {
if ($prc_is_zero) {
 push(@zero_report, $rec);
} elsif ($prc_senior_not_40) {
push(@senior_not_40_report, $rec);
} elsif ($prc_sub_not_25) {
push(@sub_not_25_report, $rec);
}
 } elsif ($pt_mismatch || $gk_mismatch || $emct_mismatch || $ca_mismatch || $storm_mismatch) {
 $rec->{prc_action} = get_mismatch_action($prc_source, $prc_sector, $pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch);
 push(@recovery_recon_report, $rec);
 add_mismatch_summary($pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch, $storm_id);
 }

 #
 $stale_cutoff = &stale_threshhold($rec);
 if (! $stale_cutoff) {
 $stale_cutoff = $default_stale_cutoff;
 }
# print "Stale Cutoff used for $prc_ticker: $stale_cutoff\n";

 if (($n_emct > 0 || $n_ca > 0 || $n_pt > 0 || $n_gk > 0) && ($prc_last_date eq "" || &diff_dates($asof, $prc_last_date) > $stale_cutoff) || $consecutive_days_closed_same ne "" ) {
 if ($i == 0) {
if ($stale_excluded) {
 $rec->{excluded} = $stale_excluded;
 push(@stale_excluded_report, $rec);
} else {
$flag = 0; #prevent duplicates from being added to product control report
if ($prc_last_date eq "" || (&diff_dates($asof, $prc_last_date) > $stale_cutoff) ) {
 push(@stale_report, $rec);
 push(@stale_report_prod_ctrl, $rec);
 $flag = 1;
 }
 if ($consecutive_days_closed_same ne "") {
 if ($flag == 0) {
 push(@stale_report_prod_ctrl, $rec);
 }
 }
}
 }
 }
}
}

sub is_dummy_curve {
my($rec) = @_;

my($excluded) = $excluded_list->{"dummy"}->{$rec->{prc_ticker}};
return $excluded if $excluded;

# Mortgages
return "" if ($rec->{prc_ticker} eq "ABXHEAAA06");
return "" if ($rec->{prc_ticker} eq "ABXHEAA06");
return "" if ($rec->{prc_ticker} eq "ABXHEA06");
return "" if ($rec->{prc_ticker} eq "ABXHEBBB06");
return "" if ($rec->{prc_ticker} eq "ABXHEBBBM6");
return "Mortgage: Dummy Curve" if ($rec->{prc_sector} =~ /Mortgage/);

return "";
}

sub no_standard() {
my($rec) = @_;

my($excluded) = $excluded_list->{"recovery"}->{$rec->{prc_ticker}};
return $excluded if $excluded;

# Paul Lim, Dan McCarthy
return "NA SN: Special Subordinated" if ($rec->{prc_ticker} eq "TSO" && $rec->{prc_subord} eq "Subordinated");

return "NSSB: non-standard rate" if ($rec->{prc_ticker} =~ /^ITRXAB5/ &&
 $rec->{prc_sector} =~ /^NSSB Credit Derivatives/);

# BeachStreet
return "NA Corr: Beach Street" if ($rec->{prc_ticker} =~ /^BEACHST/ &&
 $rec->{prc_iname} =~ /^LL/);

return "";
}

sub excluded_stale() {
my($rec) = @_;

$is_dummy = is_dummy_curve($rec);
return $is_dummy if $is_dummy;

my($excluded) = $excluded_list->{"stale"}->{$rec->{prc_ticker}};
return $excluded if $excluded;

return "";
}

sub excluded_rating() {
my($rec) = @_;

##$is_dummy = is_dummy_curve($rec);
##return $is_dummy if ($is_dummy =~ /Dummy/);

my($excluded) = $excluded_list->{"rating"}->{$rec->{prc_ticker}};
if ($excluded) {
 $desk = &get_summary_desk($rec->{prc_sector});
 return $desk;
}

return "";
}

# Threshold
sub stale_threshhold() {
my($rec) = @_;

my($threshhold) = $excluded_list->{"threshhold"}->{$rec->{prc_ticker}};
if ($threshhold) {
 return $threshhold;
}

return "";
}

sub get_mismatch_action() {
my($source, $sector, $pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch) = @_;
my($action);
$action = "Correct the break of:";

if ($storm_mismatch && $sector =~ /^Latin/) {
 $action .= " $source/Storm.";
} else {
$action .= " EMCT" if ($emct_mismatch);
 $action .= " Calypso" if ($ca_mismatch);
 $action .= " PT" if ($pt_mismatch);
 $action .= " Storm" if ($storm_mismatch);
 $action .= " GK" if ($gk_mismatch);
 $action .= ".";
}

if ($source ne "blotter") {
 $action .= " Change pricing source to blotter.";
}

return $action;
}

sub get_action() {
my($source, $sector, $recovery, $recovery_lo) = @_;
my($action);

if ($source eq "gk") {
 return "Change pricing source to blotter.";
}

if ($recovery < 0) {
 $action = "Change $source recovery to non-zero.";
} elsif ($recovery == $recovery_lo) {
 $action = "Change $source recovery to $recovery.";
} else {
 $action = "Change $source recovery to (${recovery_lo}, ${recovery}).";
}
if ($source ne "blotter") {
 if ($sector eq "" || $source eq "gk") {
 $action .= " Change pricing source to blotter.";
 } else {
 $action .= " Change pricing source to blotter.";
 }
}

return $action;
}

sub allow_zero_recovery() {
my($prc_sector) = @_;

return ($prc_sector =~ /Mortgage/);
}

# return -1 if there is no standard
sub get_standard_recovery() {
my($prc_sector, $prc_subord, $prc_ticker, $prc_iname, $hi_lo) = @_;

if ($prc_sector =~ /Mortgage/) {
 return -1;
}

if ($prc_sector =~ /^North America/) {
 if ($prc_subord =~ /^Senior Unsecured/) {
 return 40;
 } elsif ($prc_subord =~ /^Subordinated/) {
 return 25;
 }
 return -1;
}

if ($prc_sector =~ /^European Single|^European Port/) {
 if ($prc_subord =~ /^Senior Unsecured/) {
 return 40;
 } elsif ($prc_subord =~ /^Subordinated/) {
 if ($hi_lo eq "HI") {
return 25;
 } else {
return 20;
 }
 }
 return -1;
}

if ($prc_sector =~ /^NSSB Credit Derivatives/) {
 if ($prc_subord =~ /^Senior Unsecured/) {
 return 35;
 } elsif ($prc_subord =~ /^Subordinated/) {
 return 30;
 }
 return -1;
}

return -1;
}

sub add_mismatch_summary() {
my($pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch, $storm_id) = @_;
$mismatch_summary->{"EMCT"} += 1 if ($emct_mismatch);
$mismatch_summary->{"Calypso"} += 1 if ($ca_mismatch);
$mismatch_summary->{"PT"} += 1 if ($pt_mismatch);
$mismatch_summary->{"Storm"} += 1 if ($storm_mismatch);
$mismatch_summary->{"GK"} += 1 if ($gk_mismatch);

if ($storm_mismatch) {
 $storm_db = $storm_id;
 $storm_db =~ s/\/.*$//;
 $storm_summary->{$storm_db} += 1;
}
}

sub print_mismatch_summary() {
my($title) = @_;

print SUM_FILE "Report Summary\n\n$title\n\n";
print_system_mismatch("EMCT");
print_system_mismatch("Calypso");
print_system_mismatch("PT");
print_system_mismatch("GK");
print_system_mismatch("Storm");
print SUM_FILE "\n";
}

sub print_system_mismatch() {
my($sys_name) = @_;
$n_mismatch = $mismatch_summary->{$sys_name};
print SUM_FILE sprintf "\t%10s%6d\n", ($sys_name, $n_mismatch);
if ($sys_name eq "Storm" && $n_mismatch > 0) {
 print SUM_FILE "\t\t by database:\n";
 foreach $storm_db (sort keys %$storm_summary) {
 $n_mismatch = $storm_summary->{$storm_db};
 print SUM_FILE sprintf "\t\t%10s%6d\n", ($storm_db, $n_mismatch);
 }
}
}

sub print_stale_report() {
my($rpt) = @_;

open(SFILE, "> stale_curve.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>Stale Curve Report</title>
</head>
<body>
Report Date: $asof
<table border="1" cellpadding="0" cellspacing="0">
<tr>
 <td bgcolor="$light_yellow">Threshold Day Count</td>
 <td bgcolor="$light_yellow">Last Closing Date</td>
 <td bgcolor="$light_yellow">User</td>
 <td bgcolor="$light_yellow">Owner</td>
 <td bgcolor="$light_yellow">Marx Ticker</td>
 <td bgcolor="$light_yellow">Marx Issuer Name</td>
 <td bgcolor="$light_yellow">CCY</td>
 <td bgcolor="$light_yellow">Subord</td>
 <td bgcolor="$light_yellow">Doc Clause</td>
 <td bgcolor="$light_yellow">Type</td>
 <td bgcolor="$light_yellow">Pricing Source</td>
 <td bgcolor="$light_yellow">Pricing Curve ID</td>
 <td bgcolor="$light_yellow">Blotter ShortCode</td>
 <td bgcolor="$light_yellow">MarkIt Name</td>
 <td bgcolor="$light_yellow">EMCT Name</td>
 <td bgcolor="$light_yellow">Calypso Name</td>
 <td bgcolor="$light_yellow">PT Name</td>
 <td bgcolor="$light_yellow">Storm Name</td>
 <td bgcolor="$light_yellow">GK Name</td>
 <td bgcolor="$light_yellow">PC Level</td>
 <td bgcolor="$light_yellow">MarkIt Level</td>
 <td bgcolor="$light_yellow">Level Diff</td>
 <td bgcolor="$light_yellow">Workdays Stale</td>
 <td bgcolor="$light_yellow">Age Bucket</td>
</tr>
EOF

foreach $rec (sort {$a->{prc_last_date} cmp $b->{prc_last_date} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

 # Set stale color
 $stale_days = &diff_dates($asof, $rec->{prc_last_date});
 if ($rec->{prc_last_date} eq "" || $stale_days >= 180) {
 $last_color = "bgcolor=\"$light_red\"";
 } elsif ($stale_days >= 90) {
 $last_color = "bgcolor=\"$light_yellow\"";
 } else {
 $last_color = "";
 }

 #AP
 # Set level difference color

 $level_diff_color = "";
 if ($rec->{diff_level_5Y} != 0 && $rec->{markit_level_5Y} == 0) {
 $level_diff_color = "bgcolor=\"$light_yellow\"";
 }
 elsif ( $rec->{diff_level_5Y} != 0 ) {
 $level_diff_color = "bgcolor=\"$light_red\"";
 }

 # Threshold
 $stale_cutoff = &stale_threshhold($rec);
 if (! $stale_cutoff) {
 $stale_cutoff = $default_stale_cutoff;
 }
 $rec->{prc_threshhold} = $stale_cutoff;

 if ( ! (($rec->{prc_last_date} eq "") || ($rec->{prc_use_level_change} =~ /Yes/)) ) {
 $temp_date = $rec->{prc_last_date};
 while ( $temp_date != $asof ) {
 $temp_date = `/export1/app/gcdrbatch/bin/bumpweekdays "${temp_date}" 1`;
 $rec->{workdays_stale}+=1;
 }
 }
 else {
 $rec->{workdays_stale} = "";
 }

 $rec->{prc_last_date} = "Never Closed" if ($rec->{prc_last_date} eq "");
 $rec->{prc_last_date} = "Closed same level" if ($rec->{prc_use_level_change} =~ /Yes/);

 if ($rec->{prc_source} eq "markit") {
 $short_code = "";
 $markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
 } else {
 $short_code = $src_id_to_name->{$rec->{prc_ref_id}};
 $markit_id = $rec->{markit_id};
 }

 $prc_sector = $rec->{prc_sector};
 $desk = &get_summary_desk($prc_sector);
 $stale_summary->{$desk} += 1;

$age_bucket="";
$age_bucket_color="#FFFFFF";
if (! defined($rec->{workdays_stale}) || $rec->{workdays_stale} eq "") {
$age_bucket="Never Closed";
$age_bucket_color=$light_red;
} elsif ($rec->{workdays_stale} >= 0 && $rec->{workdays_stale} <= 15) {
$age_bucket = "0-15";
$age_bucket_color=$light_yellow;
} elsif ($rec->{workdays_stale} >= 16 && $rec->{workdays_stale} <= 30) {
$age_bucket="16-30";
$age_bucket_color=$orange;
} elsif ($rec->{workdays_stale} >= 31) {
$age_bucket="31+";
$age_bucket_color=$light_red;
}

 print SFILE <<EOF;
<tr>
 <td>$rec->{prc_threshhold}</td>
 <td $last_color>$rec->{prc_last_date}</td>
 <td>$rec->{prc_last_user}</td>
 <td>$rec->{prc_sector}</td>
 <td>$rec->{prc_ticker}</td>
 <td>$rec->{prc_iname}</td>
 <td>$rec->{prc_currency}</td>
 <td>$rec->{prc_subord}</td>
 <td>$rec->{prc_doc_id}</td>
 <td>$rec->{prc_type}</td>
 <td>$rec->{prc_source}</td>
 <td>$rec->{prc_curve_id}</td>
 <td>$short_code</td>
 <td>$markit_id</td>
 <td>$rec->{emct_id}</td>
 <td>$rec->{ca_id}</td>
 <td>$rec->{pt_id}</td>
 <td>$rec->{storm_id}</td>
 <td>$rec->{gk_id}</td>
 <td>$rec->{prc_level_5Y}</td>
 <td>$rec->{markit_level_5Y}</td>
 <td $level_diff_color>$rec->{diff_level_5Y}</td>
 <td>$rec->{workdays_stale}</td>
 <td bgcolor="$age_bucket_color">$age_bucket</td>
</tr>
EOF
}

print SFILE <<EOF;
</table>
</body>
</html>
EOF

close (SFILE);

$tot_mismatch = 0;
if (keys %$stale_summary > 0) {
 foreach $desk (sort keys %$stale_summary) {
 $n_mismatch = $stale_summary->{$desk};
 print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
 $tot_mismatch += $n_mismatch
 }
} else {
 print SUM_FILE sprintf "\t%35s\n", ("None");
}
print SUM_FILE sprintf "\n\t%35s%6d\n\n", (Total,$tot_mismatch);

print SUM_FILE sprintf "Following businesses use last changed dates instead of last closed to check staleness:\n\n";
my($use_level_change) = $excluded_list->{"level_change"};
if (keys %$use_level_change > 0) {
 foreach $desk (sort keys %$use_level_change) {
 print SUM_FILE sprintf "\t%35s\n", ($desk);
 }
} else {
 print SUM_FILE sprintf "\t%35s\n", ("None");
}

}

#Marx Stale Curve Report - Product Control
sub print_prod_cntrl_report() {
my($rpt) = @_;

open(SFILE, "> stale_curve_product_control.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>Marx Stale Curve Report - Product Control</title>
</head>
<body>
Report Date: $asof
<table border="1" cellpadding="0" cellspacing="0">
<tr>
 <td bgcolor="$light_yellow">Threshold Day Count</td>
 <td bgcolor="$light_yellow">Last Closing Date</td>
 <td bgcolor="$light_yellow">Days Closed At Same Levels</td>
 <td bgcolor="$light_yellow">User</td>
 <td bgcolor="$light_yellow">Owner</td>
 <td bgcolor="$light_yellow">Marx Ticker</td>
 <td bgcolor="$light_yellow">Marx Issuer Name</td>
 <td bgcolor="$light_yellow">CCY</td>
 <td bgcolor="$light_yellow">Subord</td>
 <td bgcolor="$light_yellow">Doc Clause</td>
 <td bgcolor="$light_yellow">Type</td>
 <td bgcolor="$light_yellow">Pricing Source</td>
 <td bgcolor="$light_yellow">Pricing Curve ID</td>
 <td bgcolor="$light_yellow">Blotter ShortCode</td>
 <td bgcolor="$light_yellow">MarkIt Name</td>
 <td bgcolor="$light_yellow">EMCT Name</td>
 <td bgcolor="$light_yellow">Calypso Name</td>
 <td bgcolor="$light_yellow">PT Name</td>
 <td bgcolor="$light_yellow">Storm Name</td>
 <td bgcolor="$light_yellow">GK Name</td>
 <td bgcolor="$light_yellow">PC 3M</td>
 <td bgcolor="$light_yellow">PC 6M</td>
 <td bgcolor="$light_yellow">PC 1Y</td>
 <td bgcolor="$light_yellow">PC 2Y</td>
 <td bgcolor="$light_yellow">PC 3Y</td>
 <td bgcolor="$light_yellow">PC 4Y</td>
 <td bgcolor="$light_yellow">PC 5Y</td>
 <td bgcolor="$light_yellow">PC 7Y</td>
 <td bgcolor="$light_yellow">PC 10Y</td>
 <td bgcolor="$light_yellow">PC 15Y</td>
 <td bgcolor="$light_yellow">PC 20Y</td>
 <td bgcolor="$light_yellow">PC 30Y</td>
 <td bgcolor="$light_yellow">Markit 3M</td>
 <td bgcolor="$light_yellow">Markit 6M</td>
 <td bgcolor="$light_yellow">Markit 1Y</td>
 <td bgcolor="$light_yellow">Markit 2Y</td>
 <td bgcolor="$light_yellow">Markit 3Y</td>
 <td bgcolor="$light_yellow">Markit 4Y</td>
 <td bgcolor="$light_yellow">Markit 5Y</td>
 <td bgcolor="$light_yellow">Markit 7Y</td>
 <td bgcolor="$light_yellow">Markit 10Y</td>
 <td bgcolor="$light_yellow">Markit 15Y</td>
 <td bgcolor="$light_yellow">Markit 20Y</td>
 <td bgcolor="$light_yellow">Markit 30Y</td>
 <td bgcolor="$light_yellow">Diff 3M</td>
 <td bgcolor="$light_yellow">Diff 6M</td>
 <td bgcolor="$light_yellow">Diff 1Y</td>
 <td bgcolor="$light_yellow">Diff 2Y</td>
 <td bgcolor="$light_yellow">Diff 3Y</td>
 <td bgcolor="$light_yellow">Diff 4Y</td>
 <td bgcolor="$light_yellow">Diff 5Y</td>
 <td bgcolor="$light_yellow">Diff 7Y</td>
 <td bgcolor="$light_yellow">Diff 10Y</td>
 <td bgcolor="$light_yellow">Diff 15Y</td>
 <td bgcolor="$light_yellow">Diff 20Y</td>
 <td bgcolor="$light_yellow">Diff 30Y</td>
</tr>
EOF

foreach $rec (sort {$a->{prc_last_date_prod_ctrl} cmp $b->{prc_last_date_prod_ctrl} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

 # Set stale color
 $stale_days = &diff_dates($asof, $rec->{prc_last_date_prod_ctrl});
 if ($rec->{prc_last_date_prod_ctrl} eq "" || $stale_days >= 180) {
 $last_color = "bgcolor=\"$light_red\"";
 } elsif ($stale_days >= 90) {
 $last_color = "bgcolor=\"$light_yellow\"";
 } else {
 $last_color = "";
 }

# #AP
# # Set level difference color
# #$level_diff_color = $rec->{diff_level_5Y} == 0 ? "" : "bgcolor=\"$light_red\"";
# if ($rec->{diff_level_5Y} != 0 && $rec->{markit_level_5Y} == 0) {
# $level_diff_color = "bgcolor=\"$light_yellow\"";
# }
# elsif ($rec->{diff_level_5Y} != 0) {
# }

 # Threshold
 $stale_cutoff = &stale_threshhold($rec);
 if (! $stale_cutoff) {
 $stale_cutoff = $default_stale_cutoff;
 }
 $rec->{prc_threshhold} = $stale_cutoff;

 $rec->{prc_last_date_prod_ctrl} = "Never Closed" if ($rec->{prc_last_date_prod_ctrl} eq "");
 $rec->{prc_last_date_prod_ctrl} = "Closed same level" if ($rec->{prc_use_level_change_prod_ctrl} =~ /Yes/);

 if ($rec->{prc_source} eq "markit") {
 $short_code = "";
 $markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
 } else {
 $short_code = $src_id_to_name->{$rec->{prc_ref_id}};
 $markit_id = $rec->{markit_id};
 }

 $prc_sector = $rec->{prc_sector};
 $desk = &get_summary_desk($prc_sector);
 $stale_summary->{$desk} += 1;

 print SFILE <<EOF;
<tr>
 <td>$rec->{prc_threshhold}</td>
 <td $last_color>$rec->{prc_last_date_prod_ctrl}</td>
 <td>$rec->{consecutive_days_closed_same}</td>
 <td>$rec->{prc_last_user}</td>
 <td>$rec->{prc_sector}</td>
 <td>$rec->{prc_ticker}</td>
 <td>$rec->{prc_iname}</td>
 <td>$rec->{prc_currency}</td>
 <td>$rec->{prc_subord}</td>
 <td>$rec->{prc_doc_id}</td>
 <td>$rec->{prc_type}</td>
 <td>$rec->{prc_source}</td>
 <td>$rec->{prc_curve_id}</td>
 <td>$short_code</td>
 <td>$markit_id</td>
 <td>$rec->{emct_id}</td>
 <td>$rec->{ca_id}</td>
 <td>$rec->{pt_id}</td>
 <td>$rec->{storm_id}</td>
 <td>$rec->{gk_id}</td>
 <td>$rec->{prc_level_3M}</td>
 <td>$rec->{prc_level_6M}</td>
 <td>$rec->{prc_level_1Y}</td>
 <td>$rec->{prc_level_2Y}</td>
 <td>$rec->{prc_level_3Y}</td>
 <td>$rec->{prc_level_4Y}</td>
 <td>$rec->{prc_level_5Y}</td>
 <td>$rec->{prc_level_7Y}</td>
 <td>$rec->{prc_level_10Y}</td>
 <td>$rec->{prc_level_15Y}</td>
 <td>$rec->{prc_level_20Y}</td>
 <td>$rec->{prc_level_30Y}</td>
 <td>$rec->{markit_level_3M}</td>
 <td>$rec->{markit_level_6M}</td>
 <td>$rec->{markit_level_1Y}</td>
 <td>$rec->{markit_level_2Y}</td>
 <td>$rec->{markit_level_3Y}</td>
 <td>$rec->{markit_level_4Y}</td>
 <td>$rec->{markit_level_5Y}</td>
 <td>$rec->{markit_level_7Y}</td>
 <td>$rec->{markit_level_10Y}</td>
 <td>$rec->{markit_level_15Y}</td>
 <td>$rec->{markit_level_20Y}</td>
 <td>$rec->{markit_level_30Y}</td>
 <td>$rec->{diff_level_3M}</td>
 <td>$rec->{diff_level_6M}</td>
 <td>$rec->{diff_level_1Y}</td>
 <td>$rec->{diff_level_2Y}</td>
 <td>$rec->{diff_level_3Y}</td>
 <td>$rec->{diff_level_4Y}</td>
 <td>$rec->{diff_level_5Y}</td>
 <td>$rec->{diff_level_7Y}</td>
 <td>$rec->{diff_level_10Y}</td>
 <td>$rec->{diff_level_15Y}</td>
 <td>$rec->{diff_level_20Y}</td>
 <td>$rec->{diff_level_30Y}</td>
</tr>
EOF
}

print SFILE <<EOF;
</table>
</body>
</html>
EOF

close (SFILE);

$tot_mismatch = 0;
if (keys %$stale_summary > 0) {
 foreach $desk (sort keys %$stale_summary) {
 $n_mismatch = $stale_summary->{$desk};
 print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
 $tot_mismatch += $n_mismatch
 }
} else {
 print SUM_FILE sprintf "\t%35s\n", ("None");
}
print SUM_FILE sprintf "\n\t%35s%6d\n\n", (Total,$tot_mismatch);
}

sub print_excluded_report() {
my($rpt, $title) = @_;

my($excluded_summary) = {};
open(SFILE, "> ${title}_excluded.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>$title excluded report</title>
</head>
<body>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
 <td bgcolor="$light_yellow">Reason</td>
 <td bgcolor="$light_yellow">Owner</td>
 <td bgcolor="$light_yellow">Marx Ticker</td>
 <td bgcolor="$light_yellow">Marx Issuer Name</td>
 <td bgcolor="$light_yellow">CCY</td>
 <td bgcolor="$light_yellow">Subord</td>
 <td bgcolor="$light_yellow">Doc Clause</td>
 <td bgcolor="$light_yellow">Type</td>
 <td bgcolor="$light_yellow">Pricing Source</td>
 <td bgcolor="$light_yellow">Pricing Curve ID</td>
 <td bgcolor="$light_yellow">Last Close Date</td>
 <td bgcolor="$light_yellow">Username</td>
 <td bgcolor="$light_yellow">Marx Recovery</td>
 <td bgcolor="$light_yellow">Blotter ShortCode</td>
 <td bgcolor="$light_yellow">MarkIt Name</td>
 <td bgcolor="$light_yellow">Mark-It Recovery</td>
 <td bgcolor="$light_yellow">EMCT Name</td>
 <td bgcolor="$light_yellow">EMCT Recovery</td>
 <td bgcolor="$light_yellow">Calypso Name</td>
 <td bgcolor="$light_yellow">Calypso Recovery</td>
 <td bgcolor="$light_yellow">PT Name</td>
 <td bgcolor="$light_yellow">PT Recovery</td>
 <td bgcolor="$light_yellow">Storm Name</td>
 <td bgcolor="$light_yellow">Storm Recovery</td>
 <td bgcolor="$light_yellow">GK Name</td>
 <td bgcolor="$light_yellow">GK Recovery</td>
</tr>
EOF

foreach $rec (sort {$a->{excluded} cmp $b->{excluded} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

 if ($rec->{prc_source} eq "markit") {
 $short_code = "";
 $markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
 } else {
 $short_code = $src_id_to_name->{$rec->{prc_ref_id}};
 $markit_id = $rec->{markit_id};
 }

 $prc_sector

猜你喜欢