def __init__(self, folder, data_format=None): r""" Initialization of the stack. Reading in the maps and creating a list of ``Map`` class objects, depending on the input format. """ self.log = log_tools.init_logger( directory="/home/{}/.astrolyze/".format(USER), name="astrolyze" ) self.gildas_formats = ['gdf', 'mean', 'velo', 'width', 'lmv', 'lmv-clean'] self.fits_formats = ['fits'] self.miriad_formats = [''] self.folder = folder self.get_list(data_format=data_format) print self.list self.stack = [] for i in self.list: self.stack += [self.get_map_format(i)] self.resolutions = [] self.units = [] self.dataFormats = [] for i in self.stack: print i self.resolutions += [i.resolution] self.units += [i.fluxUnit] self.dataFormats = [i.dataFormat] self.log = log_tools.init_logger( directory="/home/{}/.astrolyze/".format(USER), name="astrolyze" )
def __init__(self, source=None, target=None, exclude_file=None, options=None, delete=False, use_ssh=False): self.log = log_tools.init_logger("rsync") self.rsync_path = "/usr/bin/rsync" if not os.path.isfile(self.rsync_path): self.log.error("Can't find rsync under {}".format(self.rsync_path)) raise SystemExit self.source = source self.target = target self.exclude_file = exclude_file self.options = options self.delete = delete self.use_ssh = use_ssh self.command = self.create_rsync_command()
def __init__(self, source_name, coordinate, flux_array, number_components=2, init_fit=True, temperature_guess=None, mass_guess=None, beta_guess=None): self.log = log_tools.init_logger( directory="/home/{}/.astrolyze/".format(USER), name="astrolyze" ) self.source_name = source_name self.coordinate = coordinate self.number_components = number_components self.temperature_guess = temperature_guess self.mass_guess = mass_guess self.beta_guess = beta_guess self.flux_array = flux_array self.fit_temperatures = None self.fit_masses = None self.fit_beta = None self.fit_done = False self.set_defaults() if init_fit: self.grey_body_fit() self.log.debug(self.info())
import os import sqlite3 import glob import datetime import subprocess import hashlib from .tools import get_file_hash from generaltools import log_tools LOG = log_tools.init_logger("transfer_inbox") SOURCE = "/home/buchbend/scratch/DCIM/" PICTURES = "/home/buchbend/scratch/Pictures/" INBOX = "INBOX" DATABASE = ".transfer.db" EXTERNAL_DATABASES = [".transfer_uta.db", ".transfer_christof.db"] FILE_TYPES = ["JPG", "MP4", "AVI"] def connect_to_database(database): conn = sqlite3.connect(database) c = conn.cursor() return conn, c def check_if_transferred(path, hash_, cursor): cursor.execute('''SELECT * FROM transferred WHERE file_name=\"{}\" and hash=\"{}\"'''.format(path, hash_)) try:
import os import re import subprocess import socket from generaltools import log_tools log = log_tools.init_logger("system_tools", log_to_file=False) def download_file(url, path_to_store): cmd = ["wget", url, path_to_store] subprocess.call(cmd) def store_package_list(output_file=None): cmd = ["dpkg", "--get-selections"] package_list = subprocess.check_output(cmd) pattern = r"^.*(deinstall|hold|purge)\n" new_list = re.sub(pattern, '', package_list, flags=re.MULTILINE) pattern = r"\s*[^de]install$" new_list = re.sub(pattern, '', package_list, flags=re.MULTILINE) if output_file: with open(output_file, "w") as file_: log.debug("Storing package list to {}".format(file_)) file_.write(new_list) else: return new_list.split("\n") def add_package_to_list(package, list_): pattern = r"^{}$".format(package) with open(list_, "r") as file_: list_string = file_.read() package_present = re.search(pattern,
def _init_logger(self, name, directory="."): """ Set up a logging file """ return log_tools.init_logger(name=name, directory=directory, log_level=logging.DEBUG)
import scipy from scipy.optimize import leastsq as least from numpy import asarray, mean, std, where, exp, log, sqrt, arange from copy import deepcopy as copy import random as rnd from generaltools import log_tools import astrolyze.functions.constants as const import astrolyze.functions.units USER = os.getenv("USER") log = log_tools.init_logger( directory="/home/{}/.astrolyze/".format(USER), name="astrolyze" ) def black_body(x, T, nu_or_lambda='nu'): r""" Calculation of the flux density of a black body at a temperature T and a wavelenght/frequency x. Parameters ---------- x : float or numpy array wavelength [GHz] or frequency [micron]; specify type in nu_or_lambda T : float [Kelvin] Temperature of the black_body nu_or_lambda : string Specify whether x is a frequency :math:`\nu` ``'nu'`` or a wavelenght
import sqlite3 import pyinotify import datetime from generaltools import log_tools from .tools import get_file_hash PICTURES = "/home/buchbend/scratch/Pictures" INBOX = "INBOX" LOG = log_tools.init_logger("monitor_inbox", "/var/log/monitor_inbox") FILE_TYPES = ["JPG", "MP4"] class MyEventHandler(pyinotify.ProcessEvent): def __init__(self, database): self.conn = sqlite3.connect(database) self.c = self.conn.cursor() try: self.c.execute('''CREATE TABLE transferred (file_name text, hash text, date_transferred date) ''') except sqlite3.OperationalError: LOG.debug("Table exists already") def process_IN_ACCESS(self, event): print "ACCESS event:", event.pathname def process_IN_ATTRIB(self, event):
def __init__(self, map_name, **kwargs): ''' Initialize a map to maps. ''' USER = os.getenv("USER") config_path = "/home/{}/.astrolyze/".format(USER) config_file = "astrolyze.cfg" self.config = ConfigParser.ConfigParser() self.config.read("{}{}".format(config_path, config_file)) # Definition of the unit nomenclatures. self.log = log_tools.init_logger( directory="/home/{}/.astrolyze/".format(USER), name="astrolyze" ) USER = os.getenv("USER") self.database_prefix = self.config.get("General", "database_prefix") self.database_prefix = self.database_prefix.format(USER) # Load configuration from config_file self.jansky_beam_names = self.config.get( "Units", "jansky_beam_names" ).split(',') self.jansky_pixel_names = self.config.get( "Units", "jansky_pixel_names" ).split(',') self.tmb_names = self.config.get( "Units", "tmb_names" ).split(',') self.MJy_per_sterad_names = self.config.get( "Units", "MJy_per_sterad_names" ).split(',') self.erg_sec_pixel_names = self.config.get( "Units", "erg_sec_pixel_names" ).split(',') self.erg_sec_beam_names = self.config.get( "Units", "erg_sec_beam_names" ).split(',') self.erg_sec_sterad_names = self.config.get( "Units", "erg_sec_sterad_names" ).split(',') self.known_units = (self.jansky_beam_names + self.jansky_pixel_names + self.tmb_names + self.MJy_per_sterad_names + self.erg_sec_beam_names + self.erg_sec_sterad_names + self.erg_sec_pixel_names) # Definition of possible data format endings for the different # programs. self.gildas_formats = self.config.get( "Formats", "gildas_formats" ).split(',') self.fits_formats = self.config.get( "Formats", "fits_formats" ).split(',') self.miriad_formats = ['',None] self.class_formats = self.config.get( "Formats", "class_formats" ).split(',') # name_convention is not needed anymore. Only kept for backward # compatibality. self.map_name = map_name # Test if the file exists. Directory for Miriad. # File for Fits and GILDAS. if ((not os.path.isdir(self.map_name) and not os.path.isfile(self.map_name))): self.log.critical( 'Exiting: {} does not exist'.format(self.map_name) ) raise SystemExit # Get Informations from the file name. self.map_nameList = map_name.split('/')[-1].split('_') if len(self.map_nameList) < 5: self.log.critical( "This map does not follow the Naming Convention for Astrolyze" ) raise SystemExit self.map_nameList = map_name.split('/')[-1].split('_') self.prefix_list = map_name.split('/')[0:-1] self.comments = [] self.source = self.map_nameList[0].split('/')[-1] if len(self.prefix_list) > 0: self.prefix = string.join(self.prefix_list, '/') + '/' elif len(self.prefix_list) == 0: self.prefix = '' self.telescope = self.map_nameList[1] self.species = self._resolveSpecies() self.fluxUnit = self.map_nameList[3] # Check dataFormat. if self.map_name.endswith('.fits'): self.dataFormat = 'fits' self.map_nameList[-1] = self.map_nameList[-1].replace( '.fits', '' ) for i in self.gildas_formats: if self.map_name.endswith('.' + i): self.dataFormat = i self.map_nameList[-1] = self.map_nameList[-1].replace( '.' + i, '' ) for i in self.class_formats: if self.map_name.endswith('.' + i): self.dataFormat = i self.map_nameList[-1] = self.map_nameList[-1].replace( '.' + i, '' ) if os.path.isdir(self.map_name): # Miriad Data Format uses directories self.dataFormat = None self.resolution = self._resolveResolution() # Entries after the fifth are considered comments. if len(self.map_nameList) > 5: for i in range(len(self.map_nameList) - 6): self.comments += [self.map_nameList[i + 5]] self.comments += [self.map_nameList[-1]] #!!!!! TODO: Bas implementation. Try should only contain very short # parts of the program otherwise errors in the program are camouflaged. try: self.connection = sqlite.connect(str(self.database_prefix) + 'parameter.db') self.cursor = self.connection.cursor() self.cursor.execute("SELECT * FROM Galaxies WHERE Name = ?", (self.source.upper(),)) self.params = self.cursor.fetchall()[0] self.type = self.params[2] self.distance = self.params[3] self.vlsr = self.params[4] self.centralPosition = self.params[5] self.pa = self.params[6] self.inclination = self.params[7] self.R25 = self.params[8] self.cursor.close() self.connection.close() except: self.params = None self.type = None self.distance = None self.vlsr = None self.centralPosition = None self.pa = None self.inclination = None self.R25 = None try: self.connection = sqlite.connect(str(self.database_prefix) + 'parameter.db') self.cursor = self.connection.cursor() self.cursor.execute("SELECT * FROM Lines WHERE Name = ?", (self.species.upper(),)) self.params = self.cursor.fetchall()[0] self.frequency = self.params[2] self.wavelength = self.params[3] self.cursor.close() self.connection.close() except: pass try: self.connection = sqlite.connect(str(self.database_prefix) + 'parameter.db') self.cursor = self.connection.cursor() self.cursor.execute("SELECT * FROM cal_error WHERE Telescope = " " ? AND Species = ?", (self.telescope.upper(), self.species.upper())) self.params = self.cursor.fetchall()[0] self.calibrationError = self.params[3] self.cursor.close() self.connection.close() except: self.calibrationError = np.nan self.get_beam_size()