Changeset 14397


Ignore:
Timestamp:
2022-04-14T21:04:41Z (4 months ago)
Author:
marios
Message:

Update scripts to manage Stout references

Copied from the Git repository.

Location:
branches/c17_branch/scripts
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/c17_branch/scripts/BiblioToTeX.pm

    r12031 r14397  
    44#
    55# Chatzikos, 2016-Jan-28
     6# Chatzikos, 2022-Apr-12
     7#       Bugfix: In custom_to_json, protect against missing 'ref' key.
     8# Chatzikos, 2022-Apr-13
     9#       Rename prep_bibtex to define_month_macros, and disable its calling
     10#       -- current installation issues warnings like:
     11#          warning: overriding existing definition of macro "sep"
    612#
    713use warnings;
     
    1723use Text::BibTeX;
    1824use URI::Escape;
     25use JSON;
    1926
    2027# Immediately flush output
     
    243250                }
    244251
    245                 $string .= ($tab x $ntabs) .'"ref" : {'."\n";
    246                 my @datatypes = sort keys $$hash{$species}{ref};
    247                 for( my $idt = 0; $idt < @datatypes; $idt++ )
    248                 {
    249                         my $datatype = $datatypes[ $idt ];
    250                         $ntabs++;
    251                         $string .= ($tab x $ntabs) ."\"$datatype\" : [";
    252                         my $nrefs = @{ $$hash{$species}{ref}{$datatype} };
    253                         if( $nrefs > 0 )
     252                if( not exists $$hash{$species}{ref} )
     253                {
     254                        # drop last comma
     255                        $string = substr( $string, 0, -2 ) ."\n";
     256                }
     257                else
     258                {
     259                        $string .= ($tab x $ntabs) .'"ref" : {'."\n";
     260                        my @datatypes = sort keys $$hash{$species}{ref};
     261                        for( my $idt = 0; $idt < @datatypes; $idt++ )
    254262                        {
     263                                my $datatype = $datatypes[ $idt ];
     264                                $ntabs++;
     265                                $string .= ($tab x $ntabs) ."\"$datatype\" : [";
     266                                my $nrefs = @{ $$hash{$species}{ref}{$datatype} };
     267                                if( $nrefs > 0 )
     268                                {
     269                                        $string .= "\n";
     270                                        for( my $iref = 0; $iref < $nrefs; $iref++ )
     271                                        {
     272                                                my $ref = $$hash{$species}{ref}{$datatype}[ $iref ];
     273                                                $ntabs++;
     274                                                $string .= ($tab x $ntabs) ."{\n";
     275                                                $ntabs++;
     276                                                my @keys = sort keys %$ref;
     277                                                for( my $ikey = 0; $ikey < @keys; $ikey++ )
     278                                                {
     279                                                        my $key = $keys[ $ikey ];
     280                                                        $string .= ($tab x $ntabs) ."\"$key\" : \"$$ref{$key}\"";
     281                                                        $string .= ","
     282                                                                if( $ikey != @keys-1 );
     283                                                        $string .= "\n";
     284                                                }
     285                                                $ntabs--;
     286                                                $string .= ($tab x $ntabs) ."}";
     287                                                $string .= ","
     288                                                        if( $iref != $nrefs-1 );
     289                                                $string .= "\n";
     290                                                $ntabs--;
     291                                        }
     292                                        $string .= ($tab x $ntabs);
     293                                }
     294                                $string .=  "]";
     295                                $string .= ","
     296                                        if( $idt != @datatypes-1 );
    255297                                $string .= "\n";
    256                                 for( my $iref = 0; $iref < $nrefs; $iref++ )
    257                                 {
    258                                         my $ref = $$hash{$species}{ref}{$datatype}[ $iref ];
    259                                         $ntabs++;
    260                                         $string .= ($tab x $ntabs) ."{\n";
    261                                         $ntabs++;
    262                                         my @keys = sort keys %$ref;
    263                                         for( my $ikey = 0; $ikey < @keys; $ikey++ )
    264                                         {
    265                                                 my $key = $keys[ $ikey ];
    266                                                 $string .= ($tab x $ntabs) ."\"$key\" : \"$$ref{$key}\"";
    267                                                 $string .= ","
    268                                                         if( $ikey != @keys-1 );
    269                                                 $string .= "\n";
    270                                         }
    271                                         $ntabs--;
    272                                         $string .= ($tab x $ntabs) ."}";
    273                                         $string .= ","
    274                                                 if( $iref != $nrefs-1 );
    275                                         $string .= "\n";
    276                                         $ntabs--;
    277                                 }
    278                                 $string .= ($tab x $ntabs);
     298                                $ntabs--;
    279299                        }
    280                         $string .=  "]";
    281                         $string .= ","
    282                                 if( $idt != @datatypes-1 );
    283                         $string .= "\n";
     300
     301                        $string .= ($tab x $ntabs) ."}\n";
    284302                        $ntabs--;
    285303                }
    286 
    287                 $string .= ($tab x $ntabs) ."}\n";
    288                 $ntabs--;
    289304
    290305                $string .= ($tab x $ntabs) ."}";
     
    493508}
    494509
    495 sub prep_bibtex
     510sub define_month_macros
    496511{
    497512        foreach my $month ( qw/jan feb mar apr may jun jul aug sep oct nov dec/ )
     
    503518sub load_cloudy_bibliography
    504519{
    505         &prep_bibtex();
     520        &define_month_macros()
     521                if 0;   # Enable if you get warnings about
     522                        # unknown macros for months
    506523
    507524        my $bibfile = Text::BibTeX::File->new( $bibliography ) ;
     
    780797sub print_exampleTeX_help
    781798{
    782         print   "\t-e      :\t create an example TeX file to test the TeX output, and a script to run latex\n";
     799        print   "\t-e      :\t create an example TeX file to test the TeX output,\n";
     800        print   "\t         \t a script to run pdflatex, and a script to clean up afterwards\n";
    783801}
    784802
     
    810828}
    811829
     830sub print_instructions
     831{
     832        my( $FILE, $tableTeX, $fname, $script_name, $comment ) = @_;
     833
     834        print $FILE "\n";
     835        print $FILE "# "        if( defined( $comment ) );
     836        print $FILE "NB NB: to remove intermediate pdflatex files, run:\t\t '. $script_name'\n";
     837        print $FILE "# "        if( defined( $comment ) );
     838        print $FILE "NB NB: to also remove ${fname}.tex, and the scripts, run: '. $script_name all'\n";
     839        print $FILE "# "        if( defined( $comment ) );
     840        print $FILE "NB NB: ${fname}.pdf, and $tableTeX are not removed by this script\n\n";
     841}
     842
    812843sub create_cleanup_script
    813844{
    814         my( $fname, $hasBiblio, $run_script ) = @_;
     845        my( $tableTeX, $fname, $hasBiblio, $run_script ) = @_;
    815846
    816847        my $script_name = "cleanup-$fname.sh";
     
    818849          or die "Error: Could not open:\t $script_name\n";
    819850
    820         my @suffix = qw/ tex log aux /;
     851        &print_instructions( \*FILE, $tableTeX, $fname, $script_name, 1 );
     852
     853        my @suffix = qw/ log aux /;
    821854        push( @suffix, qw/ blg bbl / )  if( $hasBiblio );
    822855        foreach my $suffix ( @suffix )
    823856        {
    824                 print FILE "rm ${fname}.${suffix}\n";
    825         }
    826 
    827         print FILE "rm $run_script\n";
    828         print FILE "rm $script_name\n"; # commit suicide
     857                my $file = $fname .".". $suffix;
     858                print FILE "[ -e $file ] && rm $file\n";
     859        }
     860
     861        print FILE 'if [ "$1" == "all" ]; then' ."\n";
     862        print FILE "\trm ". $fname .".tex\n";
     863        print FILE "\trm $run_script\n";
     864        print FILE "\trm $script_name\n";       # commit suicide
     865        print FILE 'fi' ."\n";
    829866
    830867        close FILE
     
    833870        print "Created example script:\t $script_name\n";
    834871
     872        &print_instructions( \*STDOUT, $tableTeX, $fname, $script_name );
     873
    835874        return  $script_name;
    836875}
     
    840879        my( $deluxeTable, $tableTeX, $hasBiblio ) = @_;
    841880
    842         $tableTeX =~ s/\.tex$//;
    843 
    844         my $fname = "$tableTeX-list.tex";
    845            $fname = "$tableTeX-deluxe-list.tex"
     881        my $tableTeX_basename = $tableTeX;
     882        $tableTeX_basename =~ s/\.tex$//;
     883
     884        my $fname = "$tableTeX_basename-list.tex";
     885           $fname = "$tableTeX_basename-deluxe-list.tex"
    846886                if( defined( $deluxeTable ) );
    847887        open FILE, "> $fname"
     
    866906        print   FILE    '\usepackage{../docs/latex/common/aas_macros}' ."\n";
    867907        print   FILE    '\begin{document}'      ."\n";
    868         print   FILE    "\\input{$tableTeX}\n";
     908        print   FILE    "\\input{$tableTeX_basename}\n";
    869909        if( defined( $hasBiblio ) )
    870910        {
     
    880920
    881921        my $run_script = &create_run_script( $fname, $hasBiblio );
    882         &create_cleanup_script( $fname, $hasBiblio, $run_script );
     922        &create_cleanup_script( $tableTeX, $fname, $hasBiblio, $run_script );
    883923}
    884924
  • branches/c17_branch/scripts/db-ref-bib2json.pl

    r12031 r14397  
    55# Crawl through the atomic data base (Stout) to gather the references to the
    66# papers the data were obtained from.  Use flag '-ni' to non-interactively
    7 # get the ADS links ONLY.  A JSON file that holds the data is created (or
    8 # updated) in the database directory (e.g., data/Stout/refs.json).
     7# get the ADS links, update NIST records, and prune the database of unused
     8# references.  A JSON file that holds the data is created (or updated) in the
     9# database directory (e.g., data/Stout/refs.json).
    910#
    1011# DESCRIPTION:
    1112#
    12 # The script begins by reading the default Cloudy bibliography data base in
    13 # common/.  This is needed for updates of the data base itself, as discussed
    14 # below.
     13# The script begins by asking for an ADS token, to be obtained from:
     14#       https://ui.adsabs.harvard.edu/user/settings/token
     15# and to use with queries to the ADS database for BibTeX records.  In non-
     16# interactive runs ('-ni' switch, see below), this step is skipped.
     17#
     18# It then reads the default Cloudy bibliography data base in common/.  This is
     19# needed for updates of the data base itself, as discussed below.
    1520#
    1621# For the data base of choice (Stout), the script reads both the default and
     
    2328# For each species, the script opens in succession the relevant data files,
    2429# parses the comment section at the end of the file, and attempts to isolate the
    25 # references.  In Stout, these are either contained between the last two fields
    26 # of stars (i.e., lines that contain only stars) in the file, or if there is
    27 # only one field of stars after the end of data, by the section header
    28 # 'Reference'.  This last limitation is due to the fact that in some Stout files
    29 # there are several fields of stars to essentially comment out unwanted sections
    30 # of the data.
     30# references.  In the Stout format, these are either contained between the last
     31# two fields of stars (i.e., lines that contain only stars) in the file, or if
     32# there is only one field of stars after the end of data, by the section header
     33# 'Reference' (may be omitted).  This last limitation is due to the fact that
     34# in some Stout files there are several fields of stars to essentially comment
     35# out unwanted sections of the data.
    3136#
    3237# Once the references have been isolated, each line is parsed in succession.
     
    4146#
    4247# Alternatively, the script may be used in non-interactive mode with the flag
    43 # '-ni'.  In this case, it gathers only the ADS links from each file, and
    44 # requires no user validation.  This is intended as a quick way to update the
    45 # JSON file.  NB NB: Pre-existing references in the JSON file that are not
    46 # ADS links are preserved by this process.
     48# '-ni'.  In this case, it does the following operations without interacting
     49# with the user: it gathers the ADS links from each file, updates NIST records
     50# (if any dates are found), and prunes references from the internal data
     51# structure that do not appear in the Stout files.  This is intended as a quick
     52# way to update the JSON file.
     53#
     54# In either mode, files that contain no references are reported in the file
     55# 'empty-files.txt'.
    4756#
    4857# Note that for Stout, the script expects each reference to occupy its own line,
     
    5564# the script proceeds to the next reference.
    5665#
    57 # If the reference isn't found, the script proceeds to query ADS.  ADS possesses
    58 # 3 data bases (AST, PHYS, and PRE -- listed on the browser at the top of the
    59 # abstract request page as 'Astronomy', 'Physics', and 'arXiv e-prints').  Each
    60 # data base is queried successively, the results are reported to the user, and
    61 # checked against the input reference for a match.  If a match is not found, the
    62 # user is asked to provide a bibcode (presumably because the used filter didn't
    63 # catch the right citation), or proceed to the next ADS data base.  If none of
    64 # the ADS data bases provide a match, the user is asked to enter a bibcode by
    65 # hand, or skip the reference.  In that event, the reference is reported as an
    66 # unmatched reference in the file 'unresolved-refs.txt', in the directory from
    67 # which the script is run.
     66# If the reference is not found, the script proceeds to query ADS.  The query
     67# results are reported to the user, and checked against the input reference for
     68# a match.  If a match is not found, the user is asked to provide a bibcode
     69# (presumably because the used filter did not catch the right citation).  If
     70# no match is found, the user is asked to enter a bibcode by hand, or skip the
     71# reference.  In that event, the reference is reported as an unmatched
     72# reference in the file 'unresolved-refs.txt', in the directory from which the
     73# script is run.
    6874#
    6975# Once a bibcode is obtained, the Cloudy bibliography is queried for it, to
    7076# make sure that the citation is truly absent from the bibliography data base.
    71 # If so, ADS is queried anew for the BibTeX entry of the citation.  Knowledge
    72 # of the data base where the match was found is important, as querying a
    73 # different data base could lead to acquiring the wrong BibTeX.  (The last data
    74 # base listed on the URL for the BibTeX request is the one that takes effect.
    75 # This is why the original ADS query was done separately for each ADS data base:
    76 # to preserve the origin of the match.  Note that all three data bases could be
    77 # searched at the same time in the original query -- as on the browser.)  The
    78 # BibTeX entry is then added to the bibliography data base, along with a unique
    79 # human-readable cross-reference.  (The bibliography data on memory are also
    80 # appropriately updated.)
     77# If so, ADS is queried anew for the BibTeX entry of the citation.
    8178#
    8279# Note that in some rare occassions, the BibTeX entry may be missing some
    8380# information.  If possible, these entries are corrected from information at
    84 # hand, and these entries are reported in the file 'broken_bibtex.txt', in
     81# hand, and these entries are reported in the file 'broken-bibtex.txt', in
    8582# the directory from which the script is run.
    8683#
     
    9289# by reading this file prior to processing the atomic data base, as discussed
    9390# above.
     91#
     92# The files 'empty-files.txt', 'broken-bibtex.txt', and 'unresolved-refs.txt'
     93# should be searched for and inspected, if they exist, after each run.  If no
     94# problems were found, the relevant files will not be created.
    9495#
    9596# This script depends on a few CPAN packages that may need to be installed:
     
    107108#       $ cpanm Astro::ADS
    108109#       $ cpanm Text::BibTeX
    109 #       $ cpanm LWP::Simple
    110110#
    111111# Usage examples:
     
    126126# Chatzikos, 2016-Mar-28
    127127#       Implement non-interactive mode.
     128# Chatzikos, 2022-Apr-12
     129#       Update and parametrize ADS URL
     130# Chatzikos, 2022-Apr-14
     131#       Let script:
     132#       - process new ADS URLs, starting with 'https://ui.adsabs';
     133#       - process Stout files that either miss the 'Reference' line,
     134#         or contain data in it;
     135#       - always process NIST refs, not only in interactive mode;
     136#       - update NIST references in data structure (for JSON file),
     137#         if needed;
     138#       - always prune non-existent refs from data structure (for JSON file),
     139#         not only in interactive mode;
     140#       - process ADAS refs, and private communications;
     141#       - report files without references, after the references have been
     142#         processed (BUGFIX).
     143#       Other improvements:
     144#       - update ADS BibTeX acquisition;
     145#       - request and store ADS tokens;
     146#       - update instructions above.
    128147#
    129148
     
    138157use Astro::ADS::Query;
    139158use Text::BibTeX;
    140 use LWP::Simple;
    141159
    142160use BiblioToTeX;
     
    202220my $unresolved_ref = "unresolved-refs.txt";
    203221
    204 my @ads_dbs = qw/ AST PHYS PRE /;
     222my $ADS_URL_service = "ui.adsabs.harvard.edu";
     223my $ADS_URL = "https://". $ADS_URL_service;
     224
     225my $ADS_URL_token = $ADS_URL ."/user/settings/token";
     226my $ADS_token = undef;
     227my $ADS_token_file = ".token.ads";
    205228
    206229my $verbose = 1;
     
    280303
    281304        return  ( $forceADSquery, $db, $dataset, \@species );
     305}
     306
     307
     308#################################################################################
     309#                                  ADS TOKEN                                    #
     310#################################################################################
     311sub get_ADS_token
     312{
     313        if( not -s $ADS_token_file )
     314        {
     315                print "Please enter an ADS token.  You may create one at:\n"
     316                  .     "\t$ADS_URL_token\n";
     317                while( 1 )
     318                {
     319                        print "Enter 40-character token:\t";
     320                        $ADS_token = <STDIN>;
     321                        chomp( $ADS_token );
     322                        last    if( defined( $ADS_token ) and
     323                                        length( $ADS_token ) == 40 );
     324                }
     325
     326                open( TOKEN, '>', $ADS_token_file )
     327                  or die "Error: Could not open $ADS_token_file\n";
     328
     329                print TOKEN "$ADS_token\n";
     330
     331                close TOKEN
     332                  or warn "Warning: Could not close $ADS_token_file\n";
     333        }
     334        else
     335        {
     336                open( TOKEN, '<', $ADS_token_file )
     337                  or die "Error: Could not open $ADS_token_file\n";
     338
     339                my @contents = <TOKEN>;
     340                $ADS_token = shift @contents;
     341                chomp( $ADS_token );
     342
     343                die "Error: Undefined ADS token"
     344                 if( not defined( $ADS_token ) or
     345                        length( $ADS_token ) != 40 );
     346
     347                close TOKEN
     348                  or warn "Warning: Could not close $ADS_token_file\n";
     349        }
    282350}
    283351
     
    507575        my $all_species = shift;
    508576
    509         my @keys_to_delete = qw/ inCloudyBib link ads_db /;
     577        my @keys_to_delete = qw/ inCloudyBib link /;
    510578
    511579        foreach my $sp ( sort keys %$all_species )
     
    833901sub query_ADS_one_db
    834902{
    835         my( $bibcode_match, $year, $authors, $ads_db ) = @_;
    836 
    837         print "Querying ADS db $ads_db ...";
     903        my( $bibcode_match, $year, $authors ) = @_;
     904
     905        print "Querying ADS...";
    838906
    839907
     
    842910                AuthorLogic     =>      "AND",
    843911                StartYear       =>      $year,
    844                 EndYear         =>      $year );
    845         $query->{OPTIONS}{db_key} = $ads_db;
     912                EndYear         =>      $year, );
    846913
    847914        my $results = $query->querydb();
     
    854921        }
    855922
    856         print   "\nADS query of $ads_db database yielded "
    857           .     @papers ." matching citations:\n";
     923        print   "\nADS query yielded " . @papers ." matching citations:\n";
    858924
    859925        foreach my $paper ( @papers )
     
    891957sub enter_bibcode_by_hand
    892958{
    893         my( $bt, $ads_db, $skip ) = @_;
     959        my( $bt, $skip ) = @_;
    894960
    895961        print "Please enter bibcode for:\n";
     
    901967        my $bibcode = <STDIN>;
    902968        chomp( $bibcode );
     969
    903970        if( $bibcode eq "" and defined( $skip ) )
    904971        {
     
    909976                print "\t => Ignoring this reference\n";
    910977        }
    911         else
    912         {
    913                 if( not defined( $ads_db ) )
    914                 {
    915                         GET_ADS_DB:
    916                         {
    917                                 print "Please enter ADS db:\t";
    918                                 $ads_db = <STDIN>;
    919                                 chomp( $ads_db );
    920                                 if( join( ' ', @ads_dbs ) !~ $ads_db )
    921                                 {
    922                                         print   "Illegal choice. Options are:\t"
    923                                           .     join( ',', @ads_dbs ) ."\n";
    924                                         goto GET_ADS_DB;
    925                                 }
    926                         }
    927                 }
    928         }
    929 
    930         return  ( $bibcode, $ads_db );
     978
     979        return  $bibcode;
    931980}
    932981
     
    941990        #       print "'@authors'\n";
    942991
    943         my( $bibcode, $ads_db );
    944         foreach my $this_ads_db ( @ads_dbs )
    945         {
    946                 $ads_db = $this_ads_db;
    947                 $bibcode = &query_ADS_one_db( $bibcode_match, $$bt{year},
    948                                                 \@authors, $this_ads_db );
    949                 last
    950                         if( defined( $bibcode ) );
    951 
    952                 ( $bibcode, $ads_db ) =
    953                         &enter_bibcode_by_hand( $bt, $ads_db, 1 );
    954 
    955                 last
    956                         if( defined( $bibcode ) );
    957 
    958                 $bibcode = $ads_db = undef;
    959         }
    960 
    961         ( $bibcode, $ads_db ) = &enter_bibcode_by_hand( $bt, $ads_db )
     992        my $bibcode =
     993                &query_ADS_one_db( $bibcode_match, $$bt{year}, \@authors );
     994
     995        $bibcode = &enter_bibcode_by_hand( $bt, 1 )
     996                if( not defined( $bibcode ) );
     997
     998        $bibcode = &enter_bibcode_by_hand( $bt )
    962999                if( not defined( $bibcode ) );
    9631000
     
    9651002        #       die;
    9661003
    967         return  ( $bibcode, $ads_db );
     1004        return  $bibcode;
    9681005}
    9691006
    9701007sub get_ads_bibtex
    9711008{
    972         my( $bibcode, $ads_db ) = @_;
    973         my $req = "http://adsabs.harvard.edu/cgi-bin/nph-bib_query"
    974                 . "?bibcode=$bibcode"
    975                 . "&data_type=BIBTEX"
    976                 . "&db_key=$ads_db"
    977                 . "&nocookieset=1";
    978         #       print "$req\n";
    979         return  &LWP::Simple::get( $req );
     1009        my( $bibcode ) = @_;
     1010
     1011        #
     1012        # For detais see:
     1013        # https://github.com/adsabs/adsabs-dev-api/blob/master/Export_API.ipynb
     1014        #
     1015        my $req = "curl -H \"Authorization: Bearer $ADS_token\""
     1016                . ' -H "Content-Type: application/json"'
     1017                . ' https://api.adsabs.harvard.edu/v1/export/bibtex'
     1018                . ' -X POST'
     1019                . " -d '{\"bibcode\":[\"$bibcode\"]}'";
     1020        print $req ."\n";
     1021        my $resp = `$req`;
     1022        $resp = &JSON::from_json( $resp );
     1023        return $$resp{export};
    9801024}
    9811025
     
    10341078        }
    10351079}
     1080
    10361081sub enter_ref_by_hand
    10371082{
     
    10411086          .     "    d to delete entry\n"
    10421087          .     " or r to enter a reference (as in, 'r: Ferland et al 2013, RMxAA, 49, 137'):\n"
    1043           .     " or l to enter a link (as in: 'l: http://adsabs.harvard.edu/abs/2007ApJ...654.1171A'):\n"
     1088          .     " or l to enter a link (as in: 'l: $ADS_URL/abs/2007ApJ...654.1171A'):\n"
    10441089          .     " or b to enter a bibcode (as in: 'b: 2007ApJ...654.1171A'):\t";
    10451090        my $read_ref = <STDIN>;
     
    11391184        my( $filename, $contents_orig ) = @_;
    11401185
    1141         my @contents = @$contents_orig;
    1142         if( grep( /Reference/, @contents ) )
    1143         {
    1144                 shift( @contents ) while ( @contents and
    1145                                                 $contents[0] !~ m/Reference/ );
    1146         }
    1147 
    11481186        my @refs;
    1149         foreach my $line ( @contents )
    1150         {
     1187        foreach my $line ( @$contents_orig )
     1188        {
     1189                print $line     if 0;
    11511190                chomp( $line );
    11521191
    1153                 $line =~ s/^#Reference://;
    1154                 $line =~ s/$comment_sentinel{stout}//;
     1192                $line =~ s/^$comment_sentinel{stout}//;
     1193                $line =~ s/^Reference://;
    11551194                my $ref = $line;
    11561195
     
    11931232
    11941233                my %ref;
    1195                 if( $ref =~ m#http://adsabs# )
     1234                if( $ref =~ m#adsabs\.harvard\.edu# )
    11961235                {
    11971236                        #       print "ref:\t '$ref'\n";
     
    12031242                        $ref{bibcode} = pop( @f );
    12041243                }
     1244                elsif( $ref =~ m/NIST/i )
     1245                {
     1246                        # The phrase 'not in NIST' appears in si_2.coll
     1247                        next if( $line =~ m/ not / );
     1248
     1249                        my $version = "NIST";
     1250                        if( $ref =~ m/.*NIST\s*(\d\d\d\d-\d\d-\d\d)/ )
     1251                        {
     1252                                $version .= "  $1";
     1253                        }
     1254                        $ref{name} = $version;
     1255                }
     1256                elsif( $ref =~ m/\s*ADAS\s*/i )
     1257                {
     1258                        my $version = "ADAS";
     1259                        if( $ref =~ m/.*ADAS\s*(\d\d\d\d-\d\d-\d\d)/ )
     1260                        {
     1261                                $version .= "  $1";
     1262                        }
     1263                        $ref{name} = $version;
     1264                }
     1265                elsif( $ref =~ m/private comm/ )
     1266                {
     1267                        $ref{name} = $ref;
     1268                }
    12051269                elsif( defined( $interactive ) )
    12061270                {
    1207                         if( $ref =~ m/NIST/ )
    1208                         {
    1209                                 $ref{name} = $ref;
    1210                         }
    1211                         else
    1212                         {
    1213                                 # Citations employ at least 3 commas
    1214                                 #
    1215                                 my $ncommas = () = $ref =~ m/,/g;
    1216                                 $ref{name} = $ref
    1217                                         if( $ncommas >= 3 );
    1218                         }
     1271                        # Citations employ at least 3 commas
     1272                        #
     1273                        my $ncommas = () = $ref =~ m/,/g;
     1274                        $ref{name} = $ref
     1275                                if( $ncommas >= 3 );
    12191276                }
    12201277                push( @refs, \%ref )
     
    13481405                }
    13491406                elsif( $$this_ref{name} !~ m/NIST/i and
     1407                        $$this_ref{name} !~ m/ADAS/i and
    13501408                        $$this_ref{name} !~ m/Chianti/i and
    13511409                        $$this_ref{name} !~ m/(unpublished|private comm)/ )
     
    13621420                                else
    13631421                                {
    1364                                         ( $$this_ref{bibcode}, $$this_ref{ads_db} ) =
    1365                                                 &query_ADS( $bt );
     1422                                        $$this_ref{bibcode} = &query_ADS( $bt );
    13661423                                }
    13671424                        }
    13681425                        else
    13691426                        {
    1370                                 ( $$this_ref{bibcode}, $$this_ref{ads_db} ) =
    1371                                         &query_ADS( $bt );
     1427                                $$this_ref{bibcode} = &query_ADS( $bt );
    13721428                                $$this_ref{inCloudyBib} = 1
    13731429                                        if( defined(
     
    14871543                return;
    14881544        }
    1489 
    1490         my $resp;
    1491         if( exists( $$ref{ads_db} ) and defined( $$ref{ads_db} ) )
    1492         {
    1493                 $resp = &get_ads_bibtex( $$ref{bibcode}, $$ref{ads_db} );
    1494         }
    1495         else
    1496         {
    1497                 foreach my $ads_db ( @ads_dbs )
    1498                 {
    1499                         $resp = &get_ads_bibtex( $$ref{bibcode}, $ads_db );
    1500                         if( defined( $resp ) and $resp ne "" )
     1545        elsif( not defined( $interactive ) )
     1546        {
     1547                print "Bibcode not in .bib:\t$$ref{bibcode}\n";
     1548                return;
     1549        }
     1550
     1551        my $resp = &get_ads_bibtex( $$ref{bibcode} );
     1552        if( defined( $resp ) and $resp ne "" )
     1553        {
     1554                &report_verbatim( $resp );
     1555                if( $resp !~ m/$$ref{bibcode}/ )
     1556                {
     1557                        if( &get_response( 1 ) eq "n" )
    15011558                        {
    1502                                 print   "ADS database queried: $ads_db,"
    1503                                   .     " for: $$ref{bibcode}, got:\n";
    1504                                 &report_verbatim( $resp );
    1505                                 if( $resp =~ m/$$ref{bibcode}/ )
    1506                                 {
    1507                                         $$ref{ads_db} = $ads_db;
    1508                                         last;
    1509                                 }
    1510                                 else
    1511                                 {
    1512                                         if( &get_response( 1 ) eq "y" )
    1513                                         {
    1514                                                 $$ref{ads_db} = $ads_db;
    1515                                                 last;
    1516                                         }
    1517                                 }
     1559                                $resp = undef;
    15181560                        }
    15191561                }
     
    15221564        if( not defined( $resp ) )
    15231565        {
    1524                 print "Did not find $$ref{bibcode}\n";
     1566                print "Bibcode not on ADS:\t$$ref{bibcode}\n";
    15251567        }
    15261568        else
     
    15671609                if( not grep( /$bibcode_esc/, @$contents ) )
    15681610                {
    1569                         my $line = "# http://adsabs.harvard.edu/abs/" . $bibcode ."\n";
     1611                        my $line = "# $ADS_URL/abs/" . $bibcode ."\n";
    15701612                        push( @lines, $line );
    15711613                }
     
    16131655        my( $db, $contents ) = @_;
    16141656
    1615         my( $ilines_stars, @refs ) = ( 0 );
    1616         do
    1617         {
    1618                 @refs = ();
     1657        my $have_Reference = 0;
     1658        $have_Reference = 1
     1659                if( grep /Reference/, @$contents );
     1660
     1661        my( $ilines_stars, $got_Reference, @refs ) = ( 0, 0 );
     1662        while( @$contents )
     1663        {
    16191664                unshift( @refs, pop( @$contents ) )
    1620                         while( defined( $$contents[ -1 ] ) and
    1621                                         $$contents[ -1 ] !~ $end_of_data{$db} );
    1622                 pop( @$contents );
    1623                 $ilines_stars++;
    1624                 #$ilines_stars = 2
    1625                 #       if( @refs and $refs[0] =~ 'Reference' );
    1626         }
    1627         while( $ilines_stars < 1 );
     1665                        while( @$contents and
     1666                                      ( $$contents[ -1 ] !~ $end_of_data{$db} and
     1667                                        $$contents[ -1 ] !~ 'Reference' ) );
     1668
     1669                last    if not defined( $$contents[ -1 ] );
     1670
     1671                my $line = pop( @$contents );
     1672                $ilines_stars++         if( $line =~ $end_of_data{$db} );
     1673                $got_Reference = 1      if( $line =~ m/Reference/i );
     1674
     1675                last    if( $ilines_stars and not $have_Reference );
     1676
     1677                if( $have_Reference and $got_Reference )
     1678                {
     1679                        # Retain reference line, as it may include data;
     1680                        # e.g.,
     1681                        #       '#Reference: http://adsabs....'
     1682                        # in stout/ni/ni_11/ni_11.tp
     1683                        #
     1684                        unshift( @refs, $line );
     1685                        last;
     1686                }
     1687        }
    16281688
    16291689        pop( @$contents )
     
    16681728                print "db = '$db'\n";
    16691729        }
     1730
    16701731        my $contents = &BiblioToTeX::read_contents( $filename );
    16711732        my $data;
     
    16761737                $data = $contents;
    16771738                $contents = $refs;
    1678                 &report_empty_files( "../data/stout/".$filename, $data, $refs );
    16791739        }
    16801740        else
     
    16821742                $data = &get_data( $db, $contents );
    16831743        }
     1744
    16841745        return
    16851746                if( not @$data );
    1686         #       print "data:\t". @$data ."\n";
    1687         #       print "rest:\t". @$contents ."\n";
     1747
     1748        if( 0 )
     1749        {
     1750                print "data:\t". @$data ."\n";
     1751                print "rest:\t". @$contents ."\n";
     1752        }
    16881753
    16891754        my $refs;
     
    17001765                $refs = &parse_lamda_comments( $filename, $contents );
    17011766        }
    1702 
    17031767
    17041768        if( defined( $interactive ) )
     
    17161780                if( defined( $interactive ) and $db eq "stout" );
    17171781
     1782        &report_empty_files( "../data/stout/".$filename, $data, $refs )
     1783                if( $db eq 'stout' );
     1784
    17181785        return  $refs;
    17191786}
     
    17541821        foreach my $hr ( @{ $refs_arr } )
    17551822        {
    1756                 if( exists( $$hr{$ref_type} ) and
    1757                         $$hr{$ref_type} eq $$file_ref{$ref_type} )
    1758                 {
    1759                         $this_hr = $hr;
    1760                         last;
     1823                if( exists( $$hr{$ref_type} ) )
     1824                {
     1825                        print "$$hr{$ref_type}\t $$file_ref{$ref_type}\n"
     1826                                if 0;
     1827                        if( ( $$hr{$ref_type} =~ 'NIST' and
     1828                                $$file_ref{$ref_type} =~ 'NIST' ) or
     1829                                $$hr{$ref_type} eq $$file_ref{$ref_type} )
     1830                        {
     1831                                $this_hr = $hr;
     1832                                last;
     1833                        }
    17611834                }
    17621835        }
     
    17851858                elsif( exists( $$ref{name} ) and $$ref{name} ne "" )
    17861859                {
    1787                         #       print "ref name=\t $$ref{name}\n";
     1860                        print "ref name=\t $$ref{name}\n"       if 0;
    17881861                        $this_hr = &get_stored_ref( $ref, 'name',
    17891862                                        $$refs_data{$sp}{ref}{$datatype} );
    1790                 }
    1791                 #       print defined( $this_hr ) ? "yes\n" : "no\n";
     1863
     1864                        # Update existing record, instead of adding a new one
     1865                        if( defined( $this_hr ) )
     1866                        {
     1867                                my $new_date;
     1868
     1869                                if( $$ref{name} =~ m/NIST +\d/ and
     1870                                        defined( $this_hr ) )
     1871                                {
     1872                                        $$ref{name} =~ m/NIST +(\d{4}-\d\d-\d\d)/;
     1873                                        $new_date = $1;
     1874                                }
     1875                                elsif( $$ref{name} =~ m/NIST *\(?\d/i )
     1876                                {
     1877                                        $$ref{name} =~ m/NIST *\(?(\d{4})/;
     1878                                        $new_date = $1;
     1879                                }
     1880
     1881                                $$this_hr{name} =~ m/NIST *(.*)/;
     1882
     1883                                my $old_date = $1;
     1884                                if( defined( $old_date ) )
     1885                                {
     1886                                        $old_date =~ s/\(//g;
     1887                                        $old_date =~ s/\)//g;
     1888                                }
     1889
     1890                                if( defined( $new_date ) and
     1891                                        defined( $old_date ) and
     1892                                        $new_date gt $old_date )
     1893                                {
     1894                                        print "Update $new_date > $old_date\n"
     1895                                                if 0;
     1896                                        $$this_hr{name} = $$ref{name};
     1897                                }
     1898                        }
     1899                }
     1900                print defined( $this_hr ) ? "yes\n" : "no\n"    if 0;
    17921901
    17931902                if( not defined( $this_hr ) )
     
    17971906        }
    17981907
    1799         if( defined( $interactive ) )
     1908        if( exists $$refs_data{$sp}{ref}{$datatype} )
    18001909        {
    18011910                # Now do the reverse: prune all stored data that are not in the
    18021911                # current version of the file
    18031912                my @rm_index;
    1804                 #       print @{ $$refs_data{$sp}{ref}{$datatype} }."\n";
     1913                print @{ $$refs_data{$sp}{ref}{$datatype} }."\n"        if 0;
    18051914                for( my $iref = 0; $iref < @{ $$refs_data{$sp}{ref}{$datatype} }; $iref++ )
    18061915                {
     
    18181927                                $this_hr = &get_stored_ref( $ref, 'name', $file_refs );
    18191928                        }
    1820                         #       print defined( $this_hr ) ? "yes\n" : "no\n";
     1929                        print defined( $this_hr ) ? "yes\n" : "no\n"    if 0;
    18211930
    18221931                        if( not defined( $this_hr ) )
     
    18751984my( $forceADSquery, $db, $ds, $species_list ) = &getInput();
    18761985
    1877 &Astro::ADS::Query::ads_mirror( 'adsabs.harvard.edu' );
     1986&get_ADS_token()
     1987        if( defined( $interactive ) );
     1988
     1989&Astro::ADS::Query::ads_mirror( $ADS_URL_service );
    18781990
    18791991&BiblioToTeX::set_globals();
     
    18992011
    19002012        my $species_hash = &get_species_subset( $species_list, $all_species, $db );
    1901         #       my @all = keys %$species_hash;
    1902         #       die "$dbdir:\t @all\n";
     2013        if( 0 )
     2014        {
     2015                my @all = keys %$species_hash;
     2016                die "$dbdir:\t @all\n";
     2017        }
    19032018
    19042019        &get_references( $forceADSquery, $db, $ds, $species_hash );
  • branches/c17_branch/scripts/db-ref-json2tex.pl

    r12031 r14397  
    5555#
    5656# Chatzikos, 2016-Jan-28
     57# Chatzikos, 2022-Apr-12
     58#       Bugfix: Count TeX rows only if data ref exists
    5759#
    5860
     
    225227
    226228        my %nrows;
    227            $nrows{energy} = @{ $$ref{energy} };
    228            $nrows{trans} = @{ $$ref{trans} };
    229            $nrows{coll} = @{ $$ref{coll} };
    230 
    231         my $nrows = $nrows{energy};
    232            $nrows = $nrows{trans}       if( $nrows{trans} > $nrows );
    233            $nrows = $nrows{coll}        if( $nrows{coll} > $nrows );
     229           $nrows{energy} = @{ $$ref{energy} } if( exists $$ref{energy} );
     230           $nrows{trans} = @{ $$ref{trans} } if( exists $$ref{trans} );
     231           $nrows{coll} = @{ $$ref{coll} } if( exists $$ref{coll} );
     232
     233        my $nrows = 0;
     234           $nrows = $nrows{energy}
     235                if( exists $nrows{energy} and $nrows{energy} > $nrows );
     236           $nrows = $nrows{trans}
     237                if( exists $nrows{trans} and $nrows{trans} > $nrows );
     238           $nrows = $nrows{coll}
     239                if( exists $nrows{coll} and $nrows{coll} > $nrows );
    234240
    235241        return  ( $nrows, { %nrows } );
     
    290296                        my $citation;
    291297                        print   $FILE   "\t\t\t";
    292                         if( $i < $$nrows_per_file{$file} )
     298                        if( exists $$nrows_per_file{$file} and
     299                                defined( $$nrows_per_file{$file} ) and
     300                                $i < $$nrows_per_file{$file} )
    293301                        {
    294302                                $citation = $$ref{$file}[ $i ]{bibcode};
Note: See TracChangeset for help on using the changeset viewer.