def _create_star(self, star_number, rows):
star = Star(self)
star_width, star_height = star.rect.size
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = star_height + 2 * star_height * rows
self.stars.add(star)
def _create_stars(self, star_number, row_number):
star = Star(self)
star_width, star_height = star.rect.x, star.rect.y
star.x = star_width + star_width * star_number
star.rect.x = star.x
star.rect.y = star.rect.height + star.rect.height * row_number
self.stars.add(star)
def _create_star(self, star_number, row_number):
star = Star(self)
star_width, star_height = star.rect.size
star.x = star_width + 40*star_width*star_number
star.rect.x = star.x + 10
star.rect.y = (5*star.rect.height + 40*star.rect.height*row_number)
self.stars.add(star)
def create_star(ai_settings, screen, stars, star_number, row_number):
star = Star(ai_settings, screen)
star_width = star.rect.width
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = star.rect.height + 2 * star.rect.height * row_number\
stars.add(star)
class Picture:
def __init__(self, width, height):
self.mWidth = width
self.mHeight = height
self.mSky = Sky(width, height)
self.mPlanet1 = Planet(200, 210, 215)
self.mPlanet1.setColor(204, 204, 204)
self.mMountain1 = Mountain(width, height)
self.mCrater1 = Crater(40, 130, 100, 100)
self.mCrater2 = Crater(35, 120, 50, 50)
self.mCrater3 = Crater(90, 10, 90, 90)
self.mCrater4 = Crater(250, 90, 100, 100)
self.mCrack1 = Crack(290, 250)
self.mCrack2 = Crack(285, 240)
self.mHill1 = Hill(175, 400)
self.mHill2 = Hill(300, 380)
self.mHill3 = Hill(500, 450)
self.mStar = Star(width, height)
return
def draw(self, surface):
self.mSky.draw(surface)
self.mPlanet1.draw(surface)
self.mMountain1.draw(surface)
self.mCrater1.draw(surface)
self.mCrater2.draw(surface)
self.mCrater3.draw(surface)
self.mCrater4.draw(surface)
self.mCrack1.draw(surface)
self.mCrack2.draw(surface)
self.mHill1.draw(surface)
self.mHill2.draw(surface)
self.mHill3.draw(surface)
self.mStar.draw(surface)
return
def add_new_sprite(self, y_pos):
LIST_OF_OBSTACLE_TYPES = [
circle_obstacle.CircleObstacle, plus_obstacle.PlusObstacle
]
# If the last sprite is an obstacle
if issubclass(type(self.last_sprite), BaseObstacle):
# Randomize whatever should be another obstacle or a color switcher (1 to 3 chance)
if random.randint(0, 2) == 0:
# Choose a random obstacle
obstacle_type = random.choice(LIST_OF_OBSTACLE_TYPES)
self.last_sprite = obstacle_type(
self.screen, y_pos - obstacle_type.OBSTACLE_SIZE)
if utils.random_bool(): # Randomize if a star should be drawn
self.map_sprites.add(
Star(self.screen, self.last_sprite.position_for_star(),
self.score.increase))
else:
# Add a color switcher
self.last_sprite = ColorSwitcher(
self.screen, y_pos - ColorSwitcher.SWITCHER_BORDER -
ColorSwitcher.SWITCHER_DIAMETER)
else:
# Choose a random obstacle
obstacle_type = random.choice(LIST_OF_OBSTACLE_TYPES)
self.last_sprite = obstacle_type(
self.screen, y_pos - obstacle_type.OBSTACLE_SIZE)
if utils.random_bool(): # Randomize if a star should be drawn
self.map_sprites.add(
Star(self.screen, self.last_sprite.position_for_star(),
self.score.increase))
def __init__(self,
star,
moment=2016.3,
instrument='LDSS3C',
npixels=500,
**starkw):
'''produce a finder chart for a given star, at a particular moment
star = either a star object, or the name of star for Simbad
(**starkw will be passed to the star creation,
if you need custom RA, DEC, proper motions)
moment = for what epoch (e.g. 2016.3) should the chart show?
instrument = a string, indicating basic size of the chart
npixels = how big the image can be; ds9 needs all on screen
'''
if type(star) == str:
# if star is a string, use it (and starkw) to create star object
self.name = star
self.star = Star(self.name, **starkw)
else:
# if star isn't a string, it must be a zachopy.star.Star object'''
self.star = star
self.name = star.name
# keep track
self.instrument = instrument
self.npixels = npixels
# define the moment this finder should represent
self.setMoment(moment)
# use ds9 to create the finder chart
self.createChart()
def create_star(screen, stars, star_number, row_number):
"""Create a star and place it in the row."""
star = Star(screen)
star.x = randint(0, 1200)
star.rect.x = star.x
star.rect.y = randint(0, 800)
stars.add(star)
def _create_stars(self):
"""Create the background of stars"""
# Make a star
star = Star(self)
# Calculate density of stars
rows = int(0.01 * (1 + 0.1 * self.settings.density) *
self.settings.screen_height)
columns = int(0.01 * (1 + 0.1 * self.settings.density) *
self.settings.screen_width)
vertical_space = self.settings.screen_height // rows
horizontal_space = self.settings.screen_width // columns
# Create full background of stars
for row in range(rows):
for column in range(columns):
star = Star(self)
# Introduce randomness element
rand_x = randint((-horizontal_space // 2),
(horizontal_space // 2))
rand_y = randint((-vertical_space // 2), (vertical_space // 2))
star.x = (horizontal_space //
2) + rand_x + horizontal_space * column
star.rect.x = star.x
star.rect.y = (vertical_space //
2) + rand_y + vertical_space * row
self.stars.add(star)
def __init__(self, config, players, ais): self._star_names = StarNamesStack() self.stars = [] for n in range(config.nb_stars): star = Star( self._star_names.pop(), random.randrange(config.window_width - 32) + 16, random.randrange(config.window_height - 32) + 16 ) self.stars.append(star) nb_planets = random.randrange( config.min_planets_per_star, config.max_planets_per_star + 1) for n in range(nb_planets): star.add_planet( random.randrange(config.window_width - 32) + 16, random.randrange(config.window_height - 32) + 16 ) self._scatter_planets(config, star) self._scatter_planets(config, star) self._scatter_stars(config) self._scatter_stars(config) for p in players: colony = self._colonize_random_planet(p) for ai in ais: colony = self._colonize_random_planet(ai)
def add_star():
star = mongo.db.stars
data = Star.jsonify(request.form)
star_id = star.insert(data)
new_star = star.find_one({'_id': star_id})
return jsonify({'result': Star.jsonify(new_star)})
def create_stars(ai_settings, screen, stars): """Create a star background.""" star = Star(ai_settings, screen) for star_number in range(ai_settings.star_number): star = Star(ai_settings, screen) star.rect.x = randint(0, ai_settings.screen_width) star.rect.y = randint(0, ai_settings.screen_height) stars.add(star)
def _create_star(self, star_number):
#Create a star and place it in the row.
star = Star(self)
star_width, star_height = star.rect.size
star.x = randint(0, self.settings.screen_width - star_width)
star.rect.x = star.x
star.rect.y = randint(0, self.settings.screen_height - star_height)
self.stars.add(star)
def create_star(s_settings, screen, stars, star_number, row_number):
"""Create an stars and place it in the row."""
star = Star(s_settings, screen)
star_width = star.rect.width
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = star.rect.height + 2 * star.rect.height * row_number
stars.add(star)
def _create_star(self, star_number, row_number):
"""Create an star and place it in the row."""
star = Star(self)
star_width, star_height = star.rect.size
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = star.rect.height + 2 * star.rect.height * row_number
self.stars.add(star)
def create_star(ai_settings, screen, stars):
'''创建一个外星人并将其放在当前行'''
star = Star(ai_settings, screen)
star_width = star.rect.width
star.x = randint(0, 1200) + star_width
star.rect.x = star.x
star.rect.y = randint(0, 600) + star.rect.height
stars.add(star)
def create_star(settings, screen, stars, star_number, row_number):
"""Create a star and place it in the row."""
star = Star(settings, screen)
star_width = star.rect.width
star.x = star_width + 1 * star_width * star_number
star.rect.x = star.x # I have to multiplying by 1.5 rather than 2 because image is so big
star.rect.y = star.rect.height + 1 * star.rect.height * row_number
stars.add(star)
def create_star(ai_settings, screen, stars, star_number, star_row_number):
"""Создание звезды."""
star = Star(ai_settings, screen)
star_width = star.rect.width
star.x = randint(star_width, ai_settings.screen_width - star_width)
star.rect.x = star.x
star.rect.y = star.rect.height + 20 * star.rect.height * star_row_number
stars.add(star)
def create_star(screen, stars, star_number, row_number):
star = Star(screen)
star_width = star.rect.width
star.x = star_width + 4 * star_width * star_number
random_x = randint(-30, 30)
random_y = randint(-30, 30)
star.rect.x = star.x + random_x
star.rect.y = star.rect.height + 4 * star.rect.height * row_number + random_y
stars.add(star)
def _create_star(self, star_number, row_number):
"""Creating star and its placement"""
star = Star(self)
star_width, star_height = star.rect.size
star.x = random.randint(-50, 50) + 5 * star_width * star_number
star.rect.x = star.x
star.rect.y = (random.randint(-50, 50) +
5 * star.rect.height * row_number) # noqa
self.stars.add(star)
def create_stars(settings, screen, stars):
for index in range(30):
star = Star(settings, screen)
x = randint(0, settings.screen_width)
y = randint(0, settings.screen_height)
star.x = x
star.rect.x = x
star.rect.y = y
stars.add(star)
def _create_star(self, row_number, max_number):
star = Star(self)
star_width, star_height = star.rect.size
star_number = randint(0, max_number)
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = star.rect.height + 2 * star.rect.height * row_number
self.stars.add(star)
def create_star(screen, stars, star_number, row_number): """Create an alien and place it in the row.""" star = Star(screen) star_width = star.rect.width random_number = randint(-15, 15) star.x = star_width + random_number * star_width * star_number star.rect.x = star.x star.rect.y = star.rect.height + random_number * star.rect.height * row_number stars.add(star)
def create_star(ai_settings, screen, stars, star_number, row_number):
"""Create a star and place it in the row."""
star = Star(ai_settings, screen)
star_width = star.rect.width
star.x = (star_width * randint(-10, 10)) + 2 * star_width * star_number
star.rect.x = star.x
star.rect.y = (star.rect.height *
randint(-10, 10)) + 2 * star.rect.height * row_number
stars.add(star)
def _create_star(self, star_number, row_number):
# Create an star and place it in the row.
star = Star(self)
star_width, star_height = star.rect.size
star.x = star_width + 2 * star_width * star_number
star.rect.x = star.x + randint(-30, 30)
star.rect.y = star.rect.height + 2 * star.rect.height * row_number + randint(
-30, 30)
self.stars.add(star)
def create_star(game_set, screen, stars, star_x, star_y):
"""Create a single star and add it to the group of stars with random position"""
star = Star(game_set, screen)
star_width = star.rect.width
star_height = star.rect.height
star.x = star_width * (1 + 2 * star_x)
star.rect.x = rand_int(0, game_set.screen_width)
star.rect.y = rand_int(0, game_set.screen_height)
stars.add(star)
def creat_star(myset, screen, stars, number_y, number_x):
# 根据坐标画星星
star = Star(myset, screen)
star_width = star.rect.width
star.x = randint(-11, 11) + 2 * star_width * number_x
star.rect.x = star.x
star.rect.y = randint(-11, 11) + 2 * star.rect.height * number_y
# print(star.rect, end='\t')
stars.add(star)
def test_star_mass():
specified = Star(0.9)
assert specified.mass_ratio == 0.9
masses = set()
for i in range(0, 100):
masses.add(Star().mass_ratio)
assert len(masses) > 1
assert min(masses) >= 0.6
assert max(masses) <= 1.3
def _create_star(self, star_number, row_star):
star = Star(self)
star_width, star_height = star.rect.size
#Create a line of stars
star.x = star_width + 2 * star_width * randint(-20, star_number)
star.rect.x = star.x
#Create a serie of row of stars
star.rect.y = star.rect.height + 2 * star_height * randint(
-20, row_star)
self.stars.add(star)
def create_star(screen, stars, star_number):
"""创建一个星星并将其放在当前行"""
star = Star(screen)
star_width = star.rect.width
# star.x = star_width + 2 * star_width * star_number
star.x = randint(0, 1000) + star_width
star.rect.x = star.x
# star.y = star.rect.height + 2 * star.rect.height * row_number
star.rect.y = randint(0, 1000) + star.rect.height
stars.add(star)
def solve_all(Data, SolvePars, PlotPars, output_file):
print '------------------------------------------------------'
print 'Initializing ...'
start_time = datetime.datetime.now()
print '- Date and time: '+start_time.strftime('%d-%b-%Y, %H:%M:%S')
print '- Star data: '+Data.star_data_fname
print '------------------------------------------------------'
fout = open(output_file, 'wb')
pars = ['age', 'mass', 'logl', 'mv', 'r']
if SolvePars.key_parameter_known == 'plx':
pars.append('logg')
values = ['mp', 'll1s', 'ul1s', 'll2s', 'ul2s', 'mean', 'std']
hd = 'id'
for par in pars:
for value in values:
hd += ','+par+'_'+value
fout.write(hd+'\n')
for star_id in Data.star_data['id']:
print ''
print '*'*len(star_id)
print star_id
print '*'*len(star_id)
s = Star(star_id)
s.get_data_from(Data)
solve_one(s, SolvePars, PlotPars)
string = "{0}".format(s.name)
for par in pars:
keys = ['most_probable',
'lower_limit_1sigma', 'upper_limit_1sigma',
'lower_limit_2sigma', 'upper_limit_2sigma']
try:
for key in keys:
string += ",{0:.3f}".format(getattr(s, 'yy'+par)[key])
except:
string += ",,,,,"
try:
string += ",{0:.3f},{1:.3f}".\
format(getattr(s, 'yy'+par)['mean'],\
getattr(s, 'yy'+par)['std'])
except:
string += ",,"
fout.write(string+"\n")
fout.close()
print ''
print '------------------------------------------------------'
end_time = datetime.datetime.now()
print '- Date and time: '+end_time.strftime('%d-%b-%Y, %H:%M:%S')
delta_t = (end_time - start_time).seconds
hours, remainder = divmod(delta_t, 3600)
minutes, seconds = divmod(remainder, 60)
print '- Time elapsed: %sH %sM %sS' % (hours, minutes, seconds)
print 'Done!'
print '------------------------------------------------------'
print ''
def __init__(self, star, moment=2016.3, instrument='LDSS3C', npixels=500, **starkw): '''produce a finder chart for a given star, at a particular moment star = either a star object, or the name of star for Simbad (**starkw will be passed to the star creation, if you need custom RA, DEC, proper motions) moment = for what epoch (e.g. 2016.3) should the chart show? instrument = a string, indicating basic size of the chart npixels = how big the image can be; ds9 needs all on screen ''' if type(star) == str: # if star is a string, use it (and starkw) to create star object self.name = star self.star = Star(self.name, **starkw) else: # if star isn't a string, it must be a zachopy.star.Star object''' self.star = star self.name = star.name # keep track self.instrument = instrument self.npixels = npixels # define the moment this finder should represent self.setMoment(moment) # use ds9 to create the finder chart self.createChart()
def __init__(self, x, y, toX, toY):
Star.__init__(self, x, y, "red")
self.xspeed = 0
self.yspeed = 0
self.fromX = x
self.fromY = y
self.toX = toX
self.toY = toY
if self.toX > self.fromX:
self.xspeed = -1
if self.toX < self.fromX:
self.xspeed = 1
if self.toY > self.fromY:
self.yspeed = -1
if self.toY < self.fromY:
self.yspeed = 1
def load_stars(filename):
stars = []
data_file = open("hip_main.dat")
count = 0
sys.stdout.write("Loading stars")
for line in data_file:
count += 1
if count % 2000 == 0:
sys.stdout.write(".")
sys.stdout.flush()
star = Star.parse(line)
if star is not None and star.distance(0, 0, 0) < 100:
stars.append(star)
print ""
data_file.close()
sun = Star("Sol", 0, 0, 0, 255, 0, 0, 0)
stars.append(sun)
return stars
def main():
parser = argparse.ArgumentParser(description="Returns photometric tables of catalog stars")
parser.add_argument('catalog',type=str,help='JSON catalog of sources.')
parser.add_argument('-WISE',type=str,required=True,help='Directory of WISE tables')
parser.add_argument('-2MASS',type=str,dest='MASS',required=True,help='Directory of 2MASS tables')
args = parser.parse_args()
# Get starlist
print 'Loading JSON data from: %s' % args.catalog
theList = Star.load(args.catalog)
print '\tLoaded %i sources.' % len(theList)
print
print 'Getting photometry from catalogs...'
t = star_photometry(theList)
print 'Locating sources in %s' % args.MASS
t = add_2MASS(t,theList,args.MASS)
print 'Locating sources in %s' % args.WISE
t = add_WISE(t,theList,args.WISE)
print
#t.write('photometry.tsv',format='ascii.tab')
#exit()
outfile = 'photometry_ZOMG'
colnames = [x for x in t.colnames if 'lam' in x]
for col in colnames:
t[col] = [99.99 if ((x is None) or (x is 'None')) else x for x in t[col]]
#for Roberta
rTable = Table()
rTable.add_columns([t[x] for x in ['ID','Gal']])
for col in ['U','B','V','R','I','J','H','K',
'3.6','4.5','5.8','8.0',
'W1','W2','W3','W4',
'F_U_Jy','F_B_Jy','F_V_Jy','F_R_Jy','F_I_Jy',
'F_J_Jy','F_H_Jy','F_K_Jy',
'F_3.6_Jy','F_4.5_Jy','F_5.8_Jy','F_8.0_Jy',
'F_W1_Jy','F_W2_Jy','F_W3_Jy','F_W4_Jy',
'F_0.36_um','lam_F_0.36_um','F_0.44_um','lam_F_0.44_um','F_0.55_um','lam_F_0.55_um','F_0.71_um','lam_F_0.71_um','F_0.97_um','lam_F_0.97_um',
'F_1.24_um','lam_F_1.24_um','F_1.66_um','lam_F_1.66_um','F_2.16_um','lam_F_2.16_um',
'F_3.55_um','lam_F_3.55_um','F_4.44_um','lam_F_4.44_um','F_5.73_um','lam_F_5.73_um','F_7.87_um','lam_F_7.87_um',
'F_3.35_um','lam_F_3.35_um','F_4.60_um','lam_F_4.60_um','F_11.56_um','lam_F_11.56_um','F_22.09_um','lam_F_22.09_um']:
c = Column([np.float(x) if x else 99.99 for x in t[col]],name=col,dtype=np.float)
rTable.add_column(c)
rTable = photo_corr(rTable)
rTable.write(outfile+'.tsv',format='ascii.tab')
rTable.write(outfile+'.fits')
exit()
newCols = []
for col in colnames:
c = Column([np.float(x) for x in t[col]],name=col,dtype=np.float)
newCols.append(c)
#print colnames
eTable = Table()
eTable.add_column(t['ID'])
#eTable.add_column(t['lam_F_0.55_um'])
#c = Column([str(x) for x in t['ID']],name='ID',dtype=str)
#eTable.add_column(c)
#eTable.add_columns([t[x] for x in colnames])
eTable.add_columns(newCols)
#print eTable['ID'].dtype
#exit()
#print eTable.colnames
#for col in eTable.colnames:
# print eTable[col]
#print eTable
outfile = 'photometry.fits'
print 'Writing table to %s' % outfile
eTable.write(outfile)
def __init__(self, x, y, color):
Star.__init__(self, x, y, color)
self.moveleft = True
def __init__(self, x, y): Star.__init__(self, x, y, "red") self.moveleft = True
class Finder(object):
def __init__(self, star,
moment=2016.3,
instrument='LDSS3C',
npixels=500, **starkw):
'''produce a finder chart for a given star, at a particular moment
star = either a star object, or the name of star for Simbad
(**starkw will be passed to the star creation,
if you need custom RA, DEC, proper motions)
moment = for what epoch (e.g. 2016.3) should the chart show?
instrument = a string, indicating basic size of the chart
npixels = how big the image can be; ds9 needs all on screen
'''
if type(star) == str:
# if star is a string, use it (and starkw) to create star object
self.name = star
self.star = Star(self.name, **starkw)
else:
# if star isn't a string, it must be a zachopy.star.Star object'''
self.star = star
self.name = star.name
# keep track
self.instrument = instrument
self.npixels = npixels
# define the moment this finder should represent
self.setMoment(moment)
# use ds9 to create the finder chart
self.createChart()
def setMoment(self, moment):
self.moment = moment
def createChart(self):
self.icrs = self.star.atEpoch(self.moment)
self.ra, self.dec = self.icrs.ra, self.icrs.dec
self.camera = Camera(self.instrument)
self.coordstring = self.icrs.to_string('hmsdms')
for letter in 'hmdm':
self.coordstring = self.coordstring.replace(letter, ':')
self.coordstring = self.coordstring.replace('s', '')
self.w = pyds9.DS9('finders')
toremove=[ 'info','panner','magnifier','buttons']
for what in toremove:
self.w.set('view {0} no'.format(what))
self.w.set("frame delete all")
self.size = self.camera.size
self.inflate = self.camera.inflate
#try:
# self.addImage('poss1_red')
#except:
# print "poss1 failed"
#try:
self.addImage('poss2ukstu_red')
#except:
# print "poss2 failed"
self.addRegions()
try:
slit_mask_regions(self.star.attributes['slits'], 'slits')
self.w.set("regions load {0}".format('slits.reg'))
except KeyError:
print "no slits found!"
self.tidy()
self.save()
def tidy(self):
self.w.set("tile mode column")
self.w.set("tile yes")
self.w.set("single")
self.w.set("zoom to fit")
self.w.set("match frame wcs")
def save(self):
utils.mkdir('finders')
for d in [finderdir, 'finders/']:
print "saveimage " + d + self.name.replace(' ', '') + ".png"
self.w.set("saveimage " + d + self.name.replace(' ', '') + ".png")
def addImage(self, survey='poss2_red'):
self.w.set("frame new")
self.w.set('single')
self.w.set( "dssstsci survey {0}".format(survey))
self.w.set("dssstsci size {0} {1} arcmin ".format(self.size*self.inflate, self.size*self.inflate))
self.w.set("dssstsci coord {0} sexagesimal ".format(self.coordstring))
def addRegions(self):
xpixels = self.w.get('''fits header keyword "'NAXIS1'" ''')
ypixels = self.w.get('''fits header keyword "'NAXIS1'" ''')
self.scale = np.minimum(int(xpixels), self.npixels)/float(xpixels)
self.w.set("width {0:.0f}".format(self.npixels))
self.w.set("height {0:.0f}".format(self.npixels))
# add circles centered on the target position
r = regions.Regions("LDSS3C", units="fk5", path=finderdir )
imageepoch = float(self.w.get('''fits header keyword "'DATE-OBS'" ''').split('-')[0])
old = self.star.atEpoch(imageepoch)
print imageepoch
print self.star.posstring(imageepoch)
current = self.star.atEpoch(self.moment)
print self.moment
print self.star.posstring(self.moment)
r.addLine(old.ra.degree, old.dec.degree, current.ra.degree, current.dec.degree, line='0 1', color='red')
print old.ra.degree, old.dec.degree, current.ra.degree, current.dec.degree
r.addCircle(current.ra.degree, current.dec.degree, "{0}'".format(self.size/2), text="{0:.1f}' diameter".format(self.size), font="bold {0:.0f}".format(np.round(self.scale*14.0)))
r.addCircle(current.ra.degree, current.dec.degree, "{0}'".format(2.0/60.0))
# add a compass
radius = self.size/60/2
r.addCompass(current.ra.degree + 0.95*radius, current.dec.degree + 0.95*radius, "{0}'".format(self.size*self.inflate/10))
r.addText(current.ra.degree, current.dec.degree - 1.1*radius, self.name + ', ' + self.star.posstring(self.moment), font='bold {0:.0f}'.format(np.round(self.scale*16.0)), color='red')
r.addText(current.ra.degree - 1.04*radius, current.dec.degree + 1.02*radius, 'd(RA)={0:+3.0f}, d(Dec)={1:+3.0f} mas/yr'.format(self.star.pmra, self.star.pmdec), font='bold {0:.0f}'.format(np.round(self.scale*12.0)), color='red')
r.addText(current.ra.degree - 1.04*radius, current.dec.degree + 0.95*radius, '(image from {0})'.format(imageepoch), font='bold {0:.0f}'.format(np.round(self.scale*10.0)), color='red')
# load regions into image
print(r)
r.write()
self.w.set("cmap invert yes")
self.w.set("colorbar no")
#self.w.set("rotate to {0}".format(int(np.round(90 -63 - self.star['rot'][0]))))
self.w.set("regions load {0}".format(r.filename))
'''
MasseyXLongFile = "tables/MASSEYXLFINAL.dat"
MasseyXLongDat = np.genfromtxt(MasseyXLongFile,skip_header=1,delimiter=';',names=['Gal','LGGS','n_LGGS','Name','V','B_V','U_B','V_R','R_I','Type','rType','RA','DEC'],dtype=['a5','a20','a1','a20','f8','f8','f8','f8','f8','a10','a5','f8','f8'],autostrip=True)
MXLtab = Table(MasseyXLongDat,meta={'title':'mXL','include':False,'num':len(MasseyXLongDat)})
ra,dec = zip(*[Star.sex2deg(ra,dec) for ra,dec in zip(MXLtab['RA'],MXLtab['DEC'])])
MXLtab.add_column(Column(ra,name='RAd'))
MXLtab.add_column(Column(dec,name='DECd'))
MXLtab.write("tables/MasseyXL.fit")
'''
McQuinn = 'tables/McQuinn_dl.fit'
McQuinnDat = Table.read(McQuinn)
RA = [np.float(x.split('+')[0][1:]) for x in McQuinnDat['SSTM3307']]
DEC = [np.float(x.split('+')[1]) for x in McQuinnDat['SSTM3307']]
RAc = Column(RA,name='RA',dtype=np.float)
DECc = Column(DEC,name='DEC',dtype=np.float)
McQuinnDat.rename_column('SSTM3307','Name')
McQuinnDat.add_column(RAc)
McQuinnDat.add_column(DECc)
McQuinnDat.meta['title'] = 'mcqS'
McQuinnDat.meta['include'] = False
McQuinnDat.meta['num'] = len(McQuinnDat)
ra,dec = zip(*[Star.sex2deg(ra,dec) for ra,dec in zip(McQuinnDat['RA'],McQuinnDat['DEC'])])
McQuinnDat.add_column(Column(ra,name='RAd'))
McQuinnDat.add_column(Column(dec,name='DECd'))
McQuinnDat.write('tables/McQuinn.fits')
def solve_one(Star, SolveParsInit, Ref=object, PlotPars=object):
sp = SolvePars()
sp.__dict__ = SolveParsInit.__dict__.copy()
if not hasattr(Star, 'model_atmosphere_grid'):
logger.info('Star has no model yet. Calculating.')
Star.get_model_atmosphere(sp.grid)
if Star.model_atmosphere_grid != sp.grid:
logger.info('Inconsistent model atmosphere grids '+
'(Star and SolvePars). '+
'Fixing problem now.')
Star.get_model_atmosphere(sp.grid)
if hasattr(Ref, 'name'):
if not hasattr(Ref, 'model_atmosphere_grid'):
logger.info('Ref star has no model yet. Calculating.')
Ref.get_model_atmosphere(sp.grid)
if Ref.model_atmosphere_grid != sp.grid:
logger.info('Inconsistent model atmosphere grids '+
'(Ref star and SolvePars). '+
'Fixing problem now.')
Ref.get_model_atmosphere(sp.grid)
dtv, dgv, dvv, stop_iter = [], [], [], False
if hasattr(Star, 'converged'):
if not Star.converged:
Star.converged = False
else:
Star.converged = False
Star.stop_iter = sp.niter
if sp.niter == 0:
Star.converged = True
print 'it Teff logg [Fe/H] vt [Fe/H]'
print '-- ---- ---- ------ ---- --------------'
for i in range(sp.niter+1):
if sp.step_teff <= 1 and sp.step_logg <= 0.01 \
and sp.step_vt <= 0.01:
if not stop_iter:
Star.converged = False
if SolveParsInit.niter > 0:
print '-- Begin final loop'
stop_iter = True
if i > 0:
if Star.iron_stats['slope_ep'] > 0:
Star.teff += sp.step_teff
else:
Star.teff -= sp.step_teff
if Star.teff > 7000:
Star.teff = 7000
if Star.iron_stats['slope_rew'] > 0:
Star.vt += sp.step_vt
else:
Star.vt -= sp.step_vt
if Star.vt < 0:
Star.vt = 0
dfe = Star.iron_stats['afe1'] - Star.iron_stats['afe2']
if dfe > 0:
Star.logg += sp.step_logg
else:
Star.logg -= sp.step_logg
if Star.logg > 5.0:
Star.logg = 5.0
if hasattr(Ref, 'name'):
Star.feh = Ref.feh + Star.iron_stats['afe']
else:
Star.feh = Star.iron_stats['afe'] - sp.solar_afe
if Star.feh > 1.0:
Star.feh = 1.0
if Star.feh > 0.5 and sp.grid != 'over':
Star.feh = 0.5
Star.get_model_atmosphere(sp.grid)
if i+1 == sp.niter or sp.niter == 0:
plot = Star.name
if hasattr(Ref, 'name'):
plot = Star.name+'-'+Ref.name
if Star.name == Ref.name:
plot = None
Star.converged = ''
else:
plot = None
is_done = iron_stats(Star, Ref=Ref, plot=plot, PlotPars=PlotPars)
print "{0:2d} {1:4d} {2:4.2f} {3:6.3f} {4:4.2f}"\
" ---> {5:6.3f}+/-{6:5.3f}".\
format(i, Star.teff, Star.logg, Star.feh, Star.vt,
Star.iron_stats['afe'], Star.iron_stats['err_afe'])
dtv.append(Star.teff)
dgv.append(Star.logg)
dvv.append(Star.vt)
if i >= 4:
if np.std(dtv[-5:]) <= 0.8*sp.step_teff and \
np.std(dgv[-5:]) <= 0.8*sp.step_logg and \
np.std(dvv[-5:]) <= 0.8*sp.step_vt:
print '-- Converged at iteration '+str(i)+ \
' of '+str(sp.niter)
if stop_iter:
plot = Star.name
if hasattr(Ref, 'name'):
plot = Star.name+'-'+Ref.name
iron_stats(Star, Ref=Ref, plot=plot, PlotPars=PlotPars)
Star.converged = True
Star.stop_iter = i
break
sp.step_teff = sp.step_teff/2
sp.step_logg = sp.step_logg/2
sp.step_vt = sp.step_vt/2
if sp.step_teff < 1 and sp.step_teff > 0:
sp.step_teff = 1
if sp.step_logg < 0.01 and sp.step_logg > 0:
sp.step_logg = 0.01
if sp.step_vt < 0.01 and sp.step_vt > 0:
sp.step_vt = 0.01
if not Star.converged:
if hasattr(Ref, 'name'):
if Star.name == Ref.name or SolveParsInit.niter == 0:
print '--'
else:
print '-- Did not achieve final convergence.'
else:
print '-- Did not achieve final convergence.'
print '------------------------------------------------------'
if hasattr(Ref, 'name'):
print ' D[Fe/H] || D[Fe/H] Fe I | D[Fe/H] Fe II'
else:
print ' A(Fe) || A(Fe I) | A(Fe II) '
print "{0:6.3f} {1:6.3f} || {2:6.3f} {3:6.3f} {4:3d} "\
"| {5:6.3f} {6:6.3f} {7:3d}".\
format(Star.iron_stats['afe'], Star.iron_stats['err_afe'],
Star.iron_stats['afe1'], Star.iron_stats['err_afe1'],
Star.iron_stats['nfe1'],
Star.iron_stats['afe2'], Star.iron_stats['err_afe2'],
Star.iron_stats['nfe2'])
print '------------------------------------------------------'
Star.sp_err = {'teff': 0, 'logg': 0, 'afe': 0, 'vt': 0}
if ((Star.converged and sp.errors == True) or \
(sp.niter == 0 and sp.errors == True and Star.converged != '')):
errors.error_one(Star, sp, Ref)
Star.err_teff = int(Star.sp_err['teff'])
Star.err_logg = Star.sp_err['logg']
Star.err_feh = Star.sp_err['afe']
Star.err_vt = Star.sp_err['vt']
print "Solution with formal errors:"
print "Teff = {0:6d} +/- {1:5d}".\
format(int(Star.teff), int(Star.sp_err['teff']))
print "log g = {0:6.3f} +/- {1:5.3f}".\
format(Star.logg, Star.sp_err['logg'])
if hasattr(Ref, 'name'):
print "D[Fe/H] = {0:6.3f} +/- {1:5.3f}".\
format(Star.iron_stats['afe'], Star.sp_err['afe'])
else:
print "A(Fe) = {0:6.3f} +/- {1:5.3f}".\
format(Star.iron_stats['afe'], Star.sp_err['afe'])
print "vt = {0:6.2f} +/- {1:5.2f}".\
format(Star.vt, Star.sp_err['vt'])
print '------------------------------------------------------'
def solve_all(Data, SolveParsInit, output_file, reference_star=None,
PlotPars=object):
print '------------------------------------------------------'
print 'Initializing ...'
start_time = datetime.datetime.now()
print '- Date and time: '+start_time.strftime('%d-%b-%Y, %H:%M:%S')
print '- Model atmospheres: '+SolveParsInit.grid
print '- Star data: '+Data.star_data_fname
print '- Line list: '+Data.lines_fname
print '------------------------------------------------------'
if reference_star:
Ref = Star(reference_star)
Ref.get_data_from(Data)
else:
Ref = None
fout = open(output_file, 'wb')
if SolveParsInit.errors:
fout.write('id,teff,logg,feh_model,vt,feh,err_feh_,'+
'feh1,err_feh1,nfe1,feh2,err_feh2,nfe2,'
'slope_ep,err_slope_ep,slope_rew,err_slope_rew,'
'stop_iter,converged,'
'err_teff,err_logg,err_feh,err_vt\n')
else:
fout.write('id,teff,logg,feh_model,vt,feh,err_feh,'+
'feh1,err_feh1,nfe1,feh2,err_feh2,nfe2,'
'slope_ep,err_slope_ep,slope_rew,err_slope_rew,'
'stop_iter,converged,'
'err_teff,err_logg,err_feh_,err_vt\n')
for star_id in Data.star_data['id']:
print ''
print '*'*len(star_id)
print star_id
print '*'*len(star_id)
s = Star(star_id)
try:
s.get_data_from(Data)
except:
logger.warning('No data found for '+s.name+\
'. Excluded from output file.')
print 'Data not found.'
#fout.write("{0},,,,,,,,,,"\
# ",,,,,,,,,,,,\n".\
# format(s.name))
continue
if ma.count(Data.lines[star_id]) == 0:
print 'Line data not found.'
continue
sp = SolvePars()
sp.__dict__ = SolveParsInit.__dict__.copy()
if reference_star:
if s.name == Ref.name:
sp.niter = 0
print 'Reference star. No calculations needed.'
#continue
if hasattr(s, 'converged') and sp.check_converged:
if s.converged == 'True':
print 'Already converged.'
continue
#sp.niter = 0
#s.converged = True
if s.name in sp.ignore:
print 'Asked to ignore.'
continue
solve_one(s, sp, Ref, PlotPars=PlotPars)
if sp.niter == 0:
s.converged = ''
fout.write("{0},{1:4d},{2:5.3f},{3},{4:4.2f},{5},{6:5.3f},"\
"{7},{8:5.3f},{9},"\
"{10},{11:5.3f},{12},{13:.6f},{14:.6f},"\
"{15:.6f},{16:.6f},{17},{18},"\
"{19:3d},{20:5.3f},{21:5.3f},{22:4.2f}\n".\
format(s.name, s.teff, s.logg, str(round(s.feh,3)), s.vt,
str(round(s.iron_stats['afe'],3)),
s.iron_stats['err_afe'],
str(round(s.iron_stats['afe1'],3)),
s.iron_stats['err_afe1'],
s.iron_stats['nfe1'],
str(round(s.iron_stats['afe2'],3)),
s.iron_stats['err_afe2'],
s.iron_stats['nfe2'],
s.iron_stats['slope_ep'],
s.iron_stats['err_slope_ep'],
s.iron_stats['slope_rew'],
s.iron_stats['err_slope_rew'],
s.stop_iter,
s.converged,
s.sp_err['teff'], s.sp_err['logg'],
s.sp_err['afe'], s.sp_err['vt']
))
fout.close()
print ''
print '------------------------------------------------------'
end_time = datetime.datetime.now()
print '- Date and time: '+end_time.strftime('%d-%b-%Y, %H:%M:%S')
delta_t = (end_time - start_time).seconds
hours, remainder = divmod(delta_t, 3600)
minutes, seconds = divmod(remainder, 60)
print '- Time elapsed: %sH %sM %sS' % (hours, minutes, seconds)
print 'Done!'
print '------------------------------------------------------'
print ''
def error_one(Star_in, SolvePars, Ref=object):
s = Star()
s.__dict__ = Star_in.__dict__.copy()
try:
Ref.get_model_atmosphere(SolvePars.grid)
logger.info('Relative abundances')
except:
logger.info('Absolute abundances')
dteff = 20
dvt = 0.02
dlogg = 0.02
s.teff = s.teff + dteff
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx1 = s.iron_stats['slope_ep']
efx1 = s.iron_stats['err_slope_ep']
gx1 = s.iron_stats['slope_rew']
egx1 = s.iron_stats['err_slope_rew']
hx1 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx1 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.teff = s.teff - 2*dteff
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx2 = s.iron_stats['slope_ep']
efx2 = s.iron_stats['err_slope_ep']
gx2 = s.iron_stats['slope_rew']
egx2 = s.iron_stats['err_slope_rew']
hx2 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx2 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.teff = s.teff + dteff
dfx = 1e0*(fx2-fx1)/(2*dteff)
efx = 1e0*(efx1+efx2)/2
dgx = 1e0*(gx2-gx1)/(2*dteff)
egx = 1e0*(egx1+egx2)/2
dhx = 1e0*(hx2-hx1)/(2*dteff)
ehx = 1e0*(ehx1+ehx2)/2
dfdt, dgdt, dhdt = dfx, dgx, dhx
eft, egt, eht = efx, egx, ehx
s.vt = s.vt + dvt
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx1 = s.iron_stats['slope_ep']
efx1 = s.iron_stats['err_slope_ep']
gx1 = s.iron_stats['slope_rew']
egx1 = s.iron_stats['err_slope_rew']
hx1 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx1 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.vt = s.vt - 2*dvt
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx2 = s.iron_stats['slope_ep']
efx2 = s.iron_stats['err_slope_ep']
gx2 = s.iron_stats['slope_rew']
egx2 = s.iron_stats['err_slope_rew']
hx2 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx2 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.vt = s.vt + dvt
dfx = 1e0*(fx2-fx1)/(2*dvt)
efx = 1e0*(efx1+efx2)/2
dgx = 1e0*(gx2-gx1)/(2*dvt)
egx = 1e0*(egx1+egx2)/2
dhx = 1e0*(hx2-hx1)/(2*dvt)
ehx = 1e0*(ehx1+ehx2)/2
dfdv, dgdv, dhdv = dfx, dgx, dhx
efv, egv, ehv = efx, egx, ehx
s.logg = s.logg + dlogg
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx1 = s.iron_stats['slope_ep']
efx1 = s.iron_stats['err_slope_ep']
gx1 = s.iron_stats['slope_rew']
egx1 = s.iron_stats['err_slope_rew']
hx1 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx1 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.logg = s.logg - 2*dlogg
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
fx2 = s.iron_stats['slope_ep']
efx2 = s.iron_stats['err_slope_ep']
gx2 = s.iron_stats['slope_rew']
egx2 = s.iron_stats['err_slope_rew']
hx2 = s.iron_stats['afe1'] - s.iron_stats['afe2']
ehx2 = np.sqrt(s.iron_stats['err_afe1']**2+
s.iron_stats['err_afe2']**2)/\
np.sqrt(s.iron_stats['nfe1']+s.iron_stats['nfe2'])
s.logg = s.logg + dlogg
dfx = 1e0*(fx2-fx1)/(2*dlogg)
efx = 1e0*(efx1+efx2)/2
dgx = 1e0*(gx2-gx1)/(2*dlogg)
egx = 1e0*(egx1+egx2)/2
dhx = 1e0*(hx2-hx1)/(2*dlogg)
ehx = 1e0*(ehx1+ehx2)/2
dfdg, dgdg, dhdg = dfx, dgx, dhx
efg, egg, ehg = efx, egx, ehx
d = matrix( [ [dfdt, dfdv, dfdg],
[dgdt, dgdv, dgdg],
[dhdt, dhdv, dhdg] ] )
di = d.I
s0 = np.mean([eft,efv,efg])
s1 = np.mean([egt,egv,egg])
s2 = np.mean([eht,ehv,ehg])
eteff = np.sqrt ( (s0*di[0, 0])**2 +
(s1*di[0, 1])**2 +
(s2*di[0, 2])**2 )
evt = np.sqrt ( (s0*di[1, 0])**2 +
(s1*di[1, 1])**2 +
(s2*di[1, 2])**2 )
elogg = np.sqrt ( (s0*di[2, 0])**2 +
(s1*di[2, 1])**2 +
(s2*di[2, 2])**2 )
s.teff = s.teff + eteff
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
ap = s.iron_stats['afe']
s.teff = s.teff - 2*eteff
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
am = s.iron_stats['afe']
s.teff = s.teff + eteff
eat = (ap-am)/2
s.logg = s.logg + elogg
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
ap = s.iron_stats['afe']
s.logg = s.logg - 2*elogg
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
am = s.iron_stats['afe']
s.logg = s.logg + elogg
eag = (ap-am)/2
s.vt = s.vt + evt
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
ap = s.iron_stats['afe']
s.vt = s.vt - 2*evt
s.get_model_atmosphere(SolvePars.grid)
specpars.iron_stats(s, Ref=Ref)
am = s.iron_stats['afe']
s.vt = s.vt + evt
eav = (ap-am)/2
ea = np.sqrt(eat**2+eag**2+eav**2+s2**2)
Star_in.sp_err = {'teff': int(eteff), 'logg': elogg, 'afe': ea, 'vt': evt}
