/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.das2.datum;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* TT2000 converter that takes leap seconds into account from us2000.
* @author jbf
*/
public class LeapSecondsConverter extends UnitsConverter {
private static Logger logger= LoggerManager.getLogger("das2.datum.uc");
public static final int T1972_LEAP = 10;
private static List<Long> leapSeconds; // number of leap seconds is the index, value is in tt2000.
private static List<Double> withoutLeapSeconds;
private static long lastUpdateMillis=0;
// the following six are a cache...
private static double us2000_st= -1;
private static double us2000_en= -1;
private static int us2000_c=-1;
private static long tt2000_st= -1;
private static long tt2000_en= -1;
private static int tt2000_c=-1;
/**
* This reads in the table of leap seconds. This will need to be updated once every six months, when
* a new leap second is announced.
* @throws IOException
* @throws MalformedURLException
* @throws NumberFormatException
* @see TimeUtil#tt2000s
*/
private static void updateLeapSeconds() throws IOException, MalformedURLException, NumberFormatException {
URL url = LeapSecondsConverter.class.getResource("/orbits/CDFLeapSeconds.txt");
logger.log(Level.FINE, "try reading leap seconds from {0}", url);
InputStream in;
try {
in= url.openStream();
} catch ( IOException ex ) {
logger.log(Level.INFO,"unable to read internal leap seconds file: {0}", url);
LoggerManager.getLogger("das2.url").log(Level.FINE, "openStream {0}", url);
url= new URL("https://cdf.gsfc.nasa.gov/html/CDFLeapSeconds.txt");
in= url.openStream();
logger.log(Level.FINE, "Using remote copy of leap seconds file at {0}", url);
}
try (BufferedReader r = new BufferedReader(new InputStreamReader(in))) {
String s = "";
leapSeconds = new ArrayList(50);
withoutLeapSeconds = new ArrayList(50);
String lastLine= s;
boolean firstLine= true;
while ( true ) {
s = r.readLine();
if ( firstLine ) {
if ( s==null ) throw new RuntimeException("Leap seconds file is empty: "+url );
if ( !s.startsWith(";") ) throw new RuntimeException( "Leap seconds file should start with semicolon (;): "+url);
firstLine= false;
}
if (s == null) {
logger.log( Level.FINE, "Last leap second read from {0} {1}", new Object[]{url, lastLine});
break;
}
if (s.startsWith(";")) {
continue;
}
String[] ss = s.trim().split("\\s+", -2);
if (ss[0].compareTo("1972") < 0) {
continue;
}
int iyear = Integer.parseInt(ss[0]);
int imonth = Integer.parseInt(ss[1]);
int iday = Integer.parseInt(ss[2]);
int ileap = (int) (Double.parseDouble(ss[3])); // I thought these could only be whole numbers
double us2000 = TimeUtil.createTimeDatum(iyear, imonth, iday, 0, 0, 0, 0).doubleValue(Units.us2000);
leapSeconds.add( ((long) us2000) * 1000L - 43200000000000L + (long) ( ileap+32 ) * 1000000000 );
withoutLeapSeconds.add( us2000 );
}
leapSeconds.add( Long.MAX_VALUE );
withoutLeapSeconds.add( Double.MAX_VALUE );
lastUpdateMillis = System.currentTimeMillis();
}
}
boolean us2000ToTT2000;
public LeapSecondsConverter( boolean us2000ToTT2000 ) {
this.us2000ToTT2000= us2000ToTT2000;
if ( us2000ToTT2000 ) {
inverse= new LeapSecondsConverter( !us2000ToTT2000 );
inverse.inverse= this;
}
}
/**
* calculate the number of leap seconds in the us2000 time. For example,
* <pre>
* {@code
* print getLeapSecondCountForUs2000( Units.us2000.parse('1972-01-01T00:00Z').doubleValue(Units.us2000) ) # results in 10
* print getLeapSecondCountForUs2000( Units.us2000.parse('2017-01-01T00:00Z').doubleValue(Units.us2000) ) # results in 37
* }
* </pre>
* This is intended to replicate the table https://cdf.gsfc.nasa.gov/html/CDFLeapSeconds.txt
* @param us2000 the time in us2000, which include the leap seconds.
* @return the number of leap seconds for the time.
* @throws IOException
*/
public synchronized static int getLeapSecondCountForUs2000( double us2000 ) throws IOException {
if ( System.currentTimeMillis()-lastUpdateMillis > 86400000 ) {
updateLeapSeconds();
}
if ( us2000 < withoutLeapSeconds.get(0) ) {
return 0;
}
for ( int i=0; i<withoutLeapSeconds.size()-1; i++ ) {
if ( withoutLeapSeconds.get(i) <= us2000 && ( i==withoutLeapSeconds.size()-1 || us2000 < withoutLeapSeconds.get(i+1) ) ) {
us2000_st= withoutLeapSeconds.get(i);
us2000_en= withoutLeapSeconds.get(i+1);
us2000_c= i+T1972_LEAP;
return i+10;
}
}
logger.severe("code shouldn't get to this point: implementation error...");
throw new RuntimeException("code shouldn't get to this point: implementation error...");
}
/**
* calculate the number of leap seconds in the tt2000 time. For example,
* <pre>
* {@code
* print getLeapSecondCountForTT2000( Units.cdfTT2000.parse('1972-01-01T00:00Z').doubleValue(Units.cdfTT2000) ) # results in 10
* print getLeapSecondCountForTT2000( 0 ) # results in 32
* print getLeapSecondCountForTT2000( Units.cdfTT2000.parse('2017-01-01T00:00Z').doubleValue(Units.cdfTT2000) ) # results in 37
* }
* </pre>
* This is intended to replicate the table https://cdf.gsfc.nasa.gov/html/CDFLeapSeconds.txt
* @param tt2000 the time in tt2000, which include the leap seconds.
* @return the number of leap seconds for the time.
* @throws IOException
*/
public synchronized static int getLeapSecondCountForTT2000( long tt2000 ) throws IOException {
//System.err.println( "since 2015-06-30T23:58:00 (sec): " + ( ( tt2000 - 488980747184000000L ) / 1e9 ) );
if ( System.currentTimeMillis()-lastUpdateMillis > 86400000 ) {
updateLeapSeconds();
}
if ( tt2000 < leapSeconds.get(0) ) {
return 0;
}
int i=0;
for ( i=0; i<leapSeconds.size()-1; i++ ) {
if ( leapSeconds.get(i) <= tt2000 && ( i==leapSeconds.size()-1 || tt2000 < leapSeconds.get(i+1) ) ) {
tt2000_st= leapSeconds.get(i);
tt2000_en= leapSeconds.get(i+1);
tt2000_c= i+10;
//System.err.println( "since 2015-06-30T23:58:00 (sec): " + ( ( tt2000 - 488980747184000000L ) / 1e9 ) + " result: "+tt2000_c );
return i+10;
}
}
return i+9; // this is when we receive Long.MAX_VALUE, presumably coming from a valid_max.
}
@Override
public UnitsConverter getInverse() {
return inverse;
}
@Override
public synchronized double convert(double value) {
try {
int leapSec;
if ( this.us2000ToTT2000 ) {
if ( us2000_st <= value && value<us2000_en ) {
leapSec= us2000_c;
} else {
leapSec= getLeapSecondCountForUs2000( value );
}
return ( value * 1000 - 43200000000000L ) + ( leapSec - 32 + 64.184 ) * 1000000000L;
} else {
if ( tt2000_st <= value && value<tt2000_en ) { // DANGER--rounding...
leapSec= tt2000_c;
} else {
leapSec= getLeapSecondCountForTT2000( (long)value );
}
return ( ( value - ( leapSec - 32 + 64.184 ) * 1000000000L ) + 43200000000000L ) / 1000.; // tt = TAI + 32.184 s = UTC + 32 + 32.184 = UTC + 64.184s, see jbf@space.physics.uiowa.edu email at 2012-02-23 12:57 CST
}
} catch ( IOException ex ) {
throw new RuntimeException("LeapSeconds file not available. This should never happen since there is a leapSeconds file within code.",ex);
}
}
}