def __init__(self, mode='normal', config=None, log=None, **kwargs):
"""Reads in absorption formalisms
Note that they are all in GHz"""
kwargs = state_variables.init_state_variables(mode, **kwargs)
self.state_vars = kwargs.keys()
self.set_state(set_mode='init', **kwargs)
self.log = utils.setupLogFile(log)
self.freqs = None
# get config
if type(config) == str:
config = pcfg.planetConfig(self.planet, configFile=config, log=log)
self.config = config
# copy config back into otherPar
self.otherPar = {}
self.otherPar['h2state'] = self.config.h2state
self.otherPar['h2newset'] = self.config.h2newset
self.otherPar['water'] = self.config.water_p
self.otherPar['ice'] = self.config.ice_p
self.otherPar['nh4sh'] = self.config.nh4sh_p
self.otherPar['nh3ice'] = self.config.nh3ice_p
self.otherPar['h2sice'] = self.config.h2sice_p
self.otherPar['ch4'] = self.config.ch4_p
self.alpha_data = None
if self.use_existing_alpha or self.scale_existing_alpha:
self.existing_alpha_setup()
else:
self.formalisms()
if self.generate_alpha:
self.start_generate_alpha()
def __init__(self, planet, mode='normal', config='config.par', log=None, **kwargs):
"""reads/computes atmospheres. This returns:
self.gas
self.cloud
self.layerProperty
on the appropriate grid."""
self.planet = planet.capitalize()
kwargs = state_variables.init_state_variables(mode, **kwargs)
self.state_vars = kwargs.keys()
self.set_state(set_mode='init', **kwargs)
if self.verbose:
print('\n---Atmosphere of {}---'.format(planet))
self.logFile = utils.setupLogFile(log)
if isinstance(config, six.string_types):
config = os.path.join(self.planet, config)
config = pcfg.planetConfig(self.planet, configFile=config, log=log)
self.config = config
# ##Create function dictionaries
self.gasGen = {}
self.gasGen['read'] = self.readGas
self.cloudGen = {}
self.cloudGen['read'] = self.readCloud
self.propGen = {}
self.propGen['compute'] = self.computeProp
if self.verbose == 'loud':
print('Planet ' + self.planet)
self.config.display()
if self.config.gasType == 'read': # this assumes that cloudType is then also 'read'
utils.log(self.logFile, '\tReading from: ' + self.config.filename, self.verbose)
utils.log(self.logFile, '\tAtmosphere file: ' + self.config.gasFile, self.verbose)
utils.log(self.logFile, '\tCloud file: ' + self.config.cloudFile, self.verbose)
def __init__(self, name, mode='normal', config='config.par', **kwargs):
"""This is the 'executive function class to compute overall planetary emission.
For both mode and kwargs look at state_variables.py
Inputs:
name: 'Jupiter', 'Saturn', 'Uranus', 'Neptune'
config: config file name. If 'planet' sets to <name>/config.par
mode: sets up for various special modes '[normal]/batch/mcmc/scale_alpha/use_alpha'
kwargs: 'verbose' and 'plot' (and other state_vars - see show_state())"""
planet_list = ['Jupiter', 'Saturn', 'Neptune', 'Uranus']
self.planet = name.capitalize()
self.header = {}
self.freqs = None
self.freqUnit = None
self.b = None
print('Planetary modeling (ver {})'.format(version))
if self.planet not in planet_list:
print("{} not found.".format(self.planet))
return
# Set up state_variables
kwargs = state_variables.init_state_variables(mode.lower(), **kwargs)
self.state_vars = kwargs.keys()
self.set_state(set_mode='init', **kwargs)
self.mode = mode
self.kwargs = kwargs
# ##Set up log file
if self.write_log_file:
runStart = datetime.datetime.now()
self.logFile = 'Logs/{}_{}.log'.format(
self.planet, runStart.strftime("%Y%m%d_%H%M"))
self.log = utils.setupLogFile(self.logFile)
utils.log(self.log, self.planet + ' start ' + str(runStart),
self.verbose)
else:
self.log = None
# ## Get config
config = os.path.join(self.planet, config)
if self.verbose:
print('Reading config file: ', config)
print("\t'{}.config.display()' to see config parameters.".format(
name[0].lower()))
self.config = pcfg.planetConfig(self.planet,
configFile=config,
log=self.log)
if self.initialize:
self.initialize_run()
def __init__(self, name, mode='normal', config='config.par', **kwargs):
"""This is the 'executive function class to compute overall planetary emission.
For both mode and kwargs look at state_variables.py
Inputs:
name: 'Jupiter', 'Saturn', 'Uranus', 'Neptune'
config: config file name. If 'planet' sets to <name>/config.par
mode: sets up for various special modes '[normal]/batch/mcmc/scale_alpha/use_alpha'
kwargs: 'verbose' and 'plot' (and other state_vars - see show_state())"""
planet_list = ['Jupiter', 'Saturn', 'Neptune', 'Uranus']
self.planet = name.capitalize()
self.header = {}
self.freqs = None
self.freqUnit = None
self.b = None
print('Planetary modeling (ver {})'.format(version))
if self.planet not in planet_list:
print("{} not found.".format(self.planet))
return
# Set up state_variables
kwargs = state_variables.init_state_variables(mode.lower(), **kwargs)
self.state_vars = kwargs.keys()
self.set_state(set_mode='init', **kwargs)
self.mode = mode
self.kwargs = kwargs
# ##Set up log file
if self.write_log_file:
runStart = datetime.datetime.now()
self.logFile = 'Logs/{}_{}.log'.format(self.planet, runStart.strftime("%Y%m%d_%H%M"))
self.log = utils.setupLogFile(self.logFile)
utils.log(self.log, self.planet + ' start ' + str(runStart), self.verbose)
else:
self.log = None
# ## Get config
config = os.path.join(self.planet, config)
if self.verbose:
print('Reading config file: ', config)
print("\t'{}.config.display()' to see config parameters.".format(name[0].lower()))
self.config = pcfg.planetConfig(self.planet, configFile=config, log=self.log)
self.config.show()
if self.initialize:
self.initialize_run()
def __init__(self,
planet,
mode='normal',
config='config.par',
log=None,
**kwargs):
"""reads/computes atmospheres. This returns:
self.gas
self.cloud
self.layerProperty
on the appropriate grid."""
self.planet = planet.capitalize()
kwargs = state_variables.init_state_variables(mode, **kwargs)
self.state_vars = kwargs.keys()
self.set_state(set_mode='init', **kwargs)
if self.verbose:
print('\n---Atmosphere of {}---'.format(planet))
self.logFile = utils.setupLogFile(log)
if type(config) == str:
config = os.path.join(self.planet, config)
config = pcfg.planetConfig(self.planet, configFile=config, log=log)
self.config = config
# ##Create function dictionaries
self.gasGen = {}
self.gasGen['read'] = self.readGas
self.cloudGen = {}
self.cloudGen['read'] = self.readCloud
self.propGen = {}
self.propGen['compute'] = self.computeProp
if self.verbose == 'loud':
print('Planet ' + self.planet)
self.config.display()
if self.config.gasType == 'read': # this assumes that cloudType is then also 'read'
utils.log(self.logFile, '\tReading from: ' + self.config.filename,
self.verbose)
utils.log(self.logFile,
'\tAtmosphere file: ' + self.config.gasFile,
self.verbose)
utils.log(self.logFile, '\tCloud file: ' + self.config.cloudFile,
self.verbose)
def __init__(self,planet,config='config.par',path=None,log=None,verbose=False,plot=True):
"""reads/computes atmospheres. This should return:
self.gas
self.cloud
self.layerProperty
on the appropriate grid
Note that the research is in the input files and modifying the tweak modules
All of the default config parameters are hard-coded here: see __init__, setConfig, showConfig."""
planet = string.capitalize(planet)
self.planet = planet
self.verbose=verbose
self.plot=plot
self.logFile = utils.setupLogFile(log)
self.batch = False
print '\n---Atmosphere of %s---' % (planet)
if type(config) == str:
config = pcfg.planetConfig(self.planet,configFile=config,log=log,verbose=verbose)
self.config = config
###Create function dictionaries
self.gasGen = {}
self.gasGen['read'] = self.readGas
self.gasGen['compute'] = self.computeGas
self.cloudGen = {}
self.cloudGen['read'] = self.readCloud
self.cloudGen['compute'] = self.computeCloud
self.propGen = {}
self.propGen['read'] = self.readProp
self.propGen['compute'] = self.computeProp
print 'Planet '+self.planet
if self.config.gasType == 'read': # this assumes that cloudType is then also 'read'
utils.log(self.logFile,'\tReading from: '+self.config.path,True)
utils.log(self.logFile,'\tAtmosphere file: '+self.config.gasFile,True)
utils.log(self.logFile,'\tCloud file: '+self.config.cloudFile,True)
if verbose:
print self.config.show()
def __init__(self, name, freqs=None, b=None, freqUnit='GHz', config='config.par', log='auto', verbose=False, plot=True):
"""This is the 'executive function class to compute overall planetary emission
Arguments here set defaults, however often get set specifically in run. See pyPlanet.pdf for documentation.
Inputs:
name: 'Jupiter', 'Saturn', 'Uranus', 'Neptune' [or 'functions' if you just want to load without running]
freqs: options are:
- int/float: does that one frequency
- list of length 3: assumes it is [start,stop,step]
- list not of length 3: does those frequencies
b: 'impact parameter' b=1 is the radius of the maximum projected disc.
Determines outType from 'spectrum','profile','image' (along with freqs to some extent)
- doublet list is one position, [0,0] is the center
- float will generate a grid at that spacing, may need to set blocks during run
- list of length > 2, assumes a line of those locations at angle of first entry (deg)
if the length is four it assumes [angle,start,stop,step]
- 'disc' for disc-averaged
- 'stamp' for postage stamp (queries values)
- list of doublet lists, evaluate at those locations
freqUnit: unit for above
config: config file name [config.par], 'manual' [equivalent none]
log: log data from run, either a file name, a 'no', or 'auto' (for auto filename)
verbose: True/False
plot: True/False"""
if name.lower()[0:4] == 'func':
return
planetList = ['Jupiter','Saturn','Neptune','Uranus']
self.planet = string.capitalize(name)
runStart = datetime.datetime.now()
self.header = {}
print 'Planetary modeling (ver '+version+')\n'
print "PLANET.PY_L51: In alpha, clouds_idp need otherPar['refr'] - still?"
if self.planet in planetList:
### Set up log file
if string.lower(log)=='auto':
self.logFile = '%s_%d%02d%02d_%02d%02d.log' % (self.planet,runStart.year,runStart.month,runStart.day,runStart.hour,runStart.minute)
elif string.lower(log)=='no':
self.logFile=None
else:
self.logFile = log
self.log=utils.setupLogFile(self.logFile,path='Logs/')
utils.log(self.log,self.planet+' start '+str(runStart),True)
self.plot = plot
self.verbose = verbose
### Some convenience values for the specific Neptune observations
self.fvla_old = [4.86,8.46,14.94,22.46,43.34]
self.fvla_new = [1.5,3.0,6.0,10.,15.,22.,33.,45.]
self.fvla = [3.0, 6.0, 10.0, 15.0, 33.0]
anglecap = 13.24
bvalcap = [0.5,0.6,0.7,0.8,0.9,0.925,0.95]
self.bvla = []
for bval in bvalcap:
self.bvla.append([-bval*math.sin(math.pi*anglecap/180.0),-bval*math.cos(math.pi*anglecap/180.0)])
### Get frequencies
if freqs != None:
freqs = self.__freqRequest__(freqs, freqUnit)
else:
self.freqUnit = freqUnit
### Get viewing
self.imRow = False
if b!= None:
b = self.__bRequest__(b,[1,1])
### Get config
if config == 'manual' or config=='none':
config = None
self.config = pcfg.planetConfig(self.planet,configFile=config,log=self.log,verbose=verbose)
### Create atmosphere: outputs are self.atm.gas, self.atm.cloud and self.atm.layerProperty
self.atm = atm.Atmosphere(self.planet,config=self.config,log=self.log,verbose=verbose,plot=plot)
self.atm.run()
self.log.flush()
def __init__(self,path=None,config=None,log=None,verbose=False,plot=False):
"""Reads in absorption formalisms
Note that they are all in GHz"""
self.verbose = verbose
self.plot = plot
self.log = utils.setupLogFile(log)
print '\n---Alpha---\n'
#Get possible constituents
if path is None:
path = pyPlanetPath
possible = []
self.constituentsAreAt=os.path.join(path,'constituents')
utils.log(self.log,'Reading in absorption modules from '+self.constituentsAreAt+'\n',True)
for d in os.listdir(self.constituentsAreAt):
fnd = os.path.join(self.constituentsAreAt,d)
if os.path.isdir(fnd):
possible.append(d)
#Import used ones - note this dynamically imports the absorption modules. It checks that directory's use.txt file.
self.constituent = {}
self.absorptionModule = {}
for c in possible:
fn = os.path.join(self.constituentsAreAt,c,'use.txt')
try:
fp = open(fn,'r')
except:
#utils.log(self.log,'No file '+fn,True)
continue
absorber = fp.readline().strip()
testabs = absorber.split('.')
if len(testabs)==2:
absorber=testabs[0]
fp.close()
constituentPath=os.path.join(self.constituentsAreAt,c)
if string.lower(absorber) != 'none':
sys.path.append(constituentPath)
try:
__import__(absorber)
self.absorptionModule[c]=sys.modules[absorber]
self.constituent[c] = absorber
except ImportError:
utils.log(self.log,"Can't load "+absorber,True)
utils.log(self.log,'Using modules:',True)
for k in self.constituent:
utils.log(self.log,'\t'+k+': '+self.constituent[k],True)
# get config
if type(config) == str:
config = pcfg.planetConfig(self.planet,configFile=config,log=log,verbose=verbose)
self.config = config
# copy config back into otherPar
self.otherPar = {}
self.otherPar['h2state'] = self.config.h2state
self.otherPar['h2newset'] = self.config.h2newset
self.otherPar['water'] = self.config.water_p
self.otherPar['ice'] = self.config.ice_p
self.otherPar['nh4sh'] = self.config.nh4sh_p
self.otherPar['nh3ice'] = self.config.nh3ice_p
self.otherPar['h2sice'] = self.config.h2sice_p
self.otherPar['ch4'] = self.config.ch4_p
