def _get_db_options(args):
"""Parse through a command line of arguments to over-ride the values
in the users .dbrc file.
If no user name is given then the environment variable $USERNAME is
used. If $USERNAME is not defined then prompt for input.
"""
import optik, getpass, sys
from optik import OptionParser
parser = OptionParser()
parser.add_option("-d",
"--database",
action="store",
type="string",
dest="database",
default="cfht",
help="Name of the SYBASE database containing TABLE",
metavar="FILE")
parser.add_option("-u",
"--user",
action="store",
type="string",
dest="user",
default=getpass.getuser(),
help="User name to access db with",
metavar="USER")
(opt, unused_args) = parser.parse_args(args)
return opt.database, opt.user, unused_args
def main():
options_table = [
Option("-d", "--db", action="store",
help="DB string to connect to"),
]
parser = OptionParser(option_list=options_table)
(options, args) = parser.parse_args()
if not options.db:
print "--db not specified"
return 1
rhnSQL.initDB(options.db)
if not args:
print "No module specified"
return 0
if '.' not in sys.path:
sys.path.append('.')
g = globals()
for module_name in args:
print "Checking module %s" % module_name
pmn = proper_module_name(module_name)
try:
m = __import__(pmn)
g[module_name] = m
except ImportError, e:
print "Unable to import module %s: %s" % (module_name, e)
continue
comps = string.split(pmn, '.')
for c in comps[1:]:
m = getattr(m, c)
for mod, name, statement in get_class_instances(m, rhnSQL.Statement):
try:
rhnSQL.prepare(statement)
except rhnSQL.SQLStatementPrepareError, e:
print "Error: %s.%s: %s" % (mod.__name__, name, e)
def run_with_optik():
"""parse the options with optik"""
parser = OptionParser()
parser.add_option("-o", "--output",
action="store", type="string", dest="outputfilename",
help="write output into FILE")
output = sys.stdout
close_output = 0
(options, args) = parser.parse_args()
try:
if options.outputfilename and options.outputfilename != "-":
output = file(options.outputfilename, "w")
close_output = 1
except IOError:
print "could not open '%s' for writing." % options.outputfilename
if output:
convertProfFiles(output, args)
if close_output:
output.close()
def _get_db_options(args):
"""Parse through a command line of arguments to over-ride the values
in the users .dbrc file.
If no user name is given then the environment variable $USERNAME is
used. If $USERNAME is not defined then prompt for input.
"""
import optik, getpass,sys
from optik import OptionParser
parser=OptionParser()
parser.add_option("-d","--database",
action="store", type="string", dest="database",
default="cfht",
help="Name of the SYBASE database containing TABLE",
metavar="FILE")
parser.add_option("-u","--user",
action="store", type="string", dest="user",
default=getpass.getuser(),
help="User name to access db with",
metavar="USER")
(opt, unused_args) = parser.parse_args(args)
return opt.database,opt.user,unused_args
hdu.data=hdu.data + hdu._bzero
del hdu.header['BSCALE']
del hdu.header['BZERO']
hdu.header['BITPIX']=pyfits._ImageBaseHDU.ImgCode[hdu.data.type()]
temp.append(hdu)
return temp
if __name__ == '__main__':
### Import some standard python.
import optik,sys
from optik import OptionParser
### parse the commandline arguements
parser = OptionParser()
parser.add_option("-o","--outfile",
action="store", type="string", dest="outfile",
help="Name of output MEF file", metavar="MEF")
parser.add_option("-q","--quiet",
action="store_false", dest="verbose", default=1,
help="run makepsf/iraf quietly?")
### the left over arguments are assumed to be fits images.
(opt,infiles)=parser.parse_args()
sys.exit(stack(opt.outfile,infiles,opt.verbose))
cmd = "mpc_gen.pl -c " + astrom
print os.access(astrom, os.R_OK)
if os.access(astrom, os.R_OK):
print cmd
os.system(cmd)
os.system("mpcIngest.pl *.MPC")
os.system("cp *.MPC /home/cadc/kavelaar/results/05AQ06B")
return (0)
if __name__ == '__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser = OptionParser()
parser.add_option("--verbose",
"-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple",
"-t",
action="store",
type="int",
default=0,
dest="triple",
help="Triple to search")
parser.add_option("--block",
"-b",
action="store",
raise TaskError, "find failed"
astrom = filenames[0] + ".measure3.cands.astrom"
if os.access(astrom, os.R_OK):
return (1)
else:
return (0)
if __name__ == '__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser = OptionParser()
parser.add_option("--verbose",
"-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple",
"-t",
action="store",
type="int",
dest="triple",
help="Triple to search")
parser.add_option(
"--epoch",
"-e",
action="store",
def _quit():
""" Quit application """
print __appname__ + " terminated"
# Stop SWAP manager
manager.stop()
# Exit application
raise SystemExit
if __name__ == "__main__":
""" Command-line SWAP Device Management Tool """
print __appname__
parser = OptionParser()
# Print version
parser.add_option("--version", action="store_true", default="False", dest="version",
help="Print version number")
# Monitor network activity
parser.add_option("--monitor", action="store_true", default="False", dest="monitor",
help="Monitor SWAP network activity")
# Sniff SWAP network
parser.add_option("--sniff", action="store_true", default="False", dest="sniff",
help="Sniff SWAP network")
# Configure device
parser.add_option("-c", "--config", action="store_true", default="False", dest="config",
help="Configure SWAP device")
parser.add_option("-d", "--device", type="string", dest="device",
help="Product name")
print astrom
cmd = "mpc_gen.pl -c "+astrom
print os.access(astrom,os.R_OK)
if os.access(astrom,os.R_OK):
print cmd
os.system(cmd)
os.system("mpcIngest.pl *.MPC")
os.system("cp *.MPC /home/cadc/kavelaar/results/05AQ06B")
return(0)
if __name__=='__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser=OptionParser()
parser.add_option("--verbose","-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple","-t",
action="store",
type="int",
default=0,
dest="triple",
help="Triple to search")
parser.add_option("--block","-b",
action="store",
dest="block",
help="CFEPS block to search")
parser.add_option("--ccd","-c",
#!/usr/bin/python
import FASTA
import random
import sys
from optik import OptionParser
usage = "usage: %prog [options] < faInput > faOutput"
parser = OptionParser(usage)
parser.add_option("-r", "--rate", type="float", dest="rate",
help="probability that a given base mutates",
default=0.1)
parser.add_option("-s", "--seed", type="int", dest="seed",
help="seed for initializing RNG",
default=None)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.error("incorrect number of arguments")
mutations = {'A': ('C', 'G', 'T'),
'C': ('A', 'G', 'T'),
'G': ('A', 'C', 'T'),
'T': ('A', 'C', 'G')}
def mutateCharacter(char, rate):
if random.random() < rate:
return random.choice(mutations[char])
else:
return char
def mutateSequence(seq, rate):
print "Result: %d matches" % len(resultset)
lst = list(resultset.items())
lst.sort(lambda x,y : -cmp(x[1],y[1]))
for docid,score in lst:
print "%-2d %s %d" % (docid, docs[docid].getId(), score)
except:
traceback.print_exc()
if __name__== '__main__':
usage = "Usage: %prog [options] "
parser = OptionParser(usage=usage)
parser.add_option('-d','--directory', action='store',type='string',
dest='directory',help='directory to be search for input files')
parser.add_option('-l','--left', action='store_true',
dest='extra_truncate_left', help='enable left truncation',default=0)
parser.add_option('-n','--neardistance', action='store',type='int',
dest='extra_near_distance',
help='max. distance between words for near search',default=5)
parser.add_option('-C','--converter', action='store',type='int',
dest='extra_use_converters',
help='use document converters',default=0)
parser.add_option('-c','--casefolding', action='store_true',
dest='extra_splitter_casefolding', help='enable casefolding',
default=1)
parser.add_option('-a','--autoexpand', action='store_true',
dest='extra_autoexpand', help='auto expand',
def main():
usage = "usage: %prog [options] epsilon sigma/Rmin"
parser = OptionParser(usage)
parser.add_option("-s",
"--sigma",
action="store_true",
dest="sigma",
default="store_false",
help="sets input type of sigma/Rmin to sigma")
parser.add_option("-r",
"--rmin",
action="store_false",
dest="sigma",
default="store_false",
help="sets input type of sigma/Rmin to Rmin")
parser.add_option("-n",
"--number",
action="store",
dest="count",
default=4,
help="particle count")
parser.add_option("-c",
"--chemcomp",
action="store",
dest="chemcomp",
default="AR",
help="chemical component")
parser.add_option("-e",
"--element",
action="store",
dest="element",
default="Ar",
help="element symbol")
parser.add_option("-t",
"--atomtag",
action="store",
dest="atomtag",
default="AR_",
help="atom tag")
parser.add_option("-m",
"--mass",
action="store",
dest="mass",
default="39.948",
help="mass (amu)")
parser.add_option("-d",
"--moleculename",
action="store",
dest="moleculename",
default="Argon",
help="molecule name")
parser.add_option("-k",
"--kelvin",
action="store_true",
dest="kelvin",
default="store_false",
help="energy units in kelvin")
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error("incorrect number of args")
if int(options.count) <= 0:
parser.error("Illegal value for particle number")
epsilon = args[0]
if options.kelvin:
epsilon = epsilon + "*SciConst::KBoltzmann_IU"
rMinValue = args[1]
if options.sigma:
rMinValue = rMinValue + "*SciConst::SixthRootOfTwo"
outputXmlHeaderWithDtd()
print("<ffparams>")
outputHeaderParameterList()
outputMoleculeName(options.moleculename, "SALT")
outputChemicalComponentInstanceList(int(options.count), options.chemcomp)
outputMoleculeInstanceList(int(options.count))
outputSiteList(int(options.count), options.mass, options.atomtag, epsilon,
rMinValue, options.element)
print("</ffparams>")
#!/usr/bin/python
"""Compute the centroids and magnitudes of an input
list of stars and a fits image.
This script is designed to work with MEGAPRIME images from CFHT"""
author = "JJ Kavelaars"
version = 1.0
import sys
import optik
from optik import OptionParser
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--image',
action='store',
help='image to compute centroids of stars')
parser.add_option(
'--input',
action='store',
help=
'coo file [in format approriate for iraf.digiphot.daophot.phot coo] ')
parser.add_option(
'--output',
action='store',
help='file with output star coordinates [X,Y,MAG,MERR,ID]')
parser.add_option('--aperture',
action='store',
return mef_psf
### set the version flag for this program
__Version__ = "$Revision: 1.1 $"
__Id__ = "$Id: ctio_mkpsf.py,v 1.1 2005/01/16 04:56:55 observe Exp $"
if __name__ == '__main__':
### Import some standard python.
import os, sys, string, tempfile, shutil
import optik
from optik import OptionParser
### parse the commandline arguements
parser = OptionParser()
parser.add_option("-f",
"--file",
action="store",
type="string",
dest="filename",
help="create PSF for FILE",
metavar="FILE")
parser.add_option("-e",
"--expnum",
action="store",
type="string",
dest="expnum",
help="exposure to get from AD",
metavar="EXPNUM")
parser.add_option(
#* Modification History:
#* $Log $
#*
#**** C A N A D I A N A S T R O N O M Y D A T A C E N T R E *****
#************************************************************************
#-*/
"""Update the WCS of a megaprime image by taking an input star list """
__Version__ = "$Revision 0.1$"
import optik, sys
from optik import OptionParser
if __name__=='__main__':
parser=OptionParser()
parser.add_option("--image",
action="store",
help="Image to modified WCS of",
dest="image")
parser.add_option("--usno",
action="store",
help="USNO catalog stars",
dest="usno")
parser.add_option("--stars",
action="store",
help="x,y location of stars in input image")
(opt, args) = parser.parse_args()
#*
#* Modification History:
#*
#**** C A N A D I A N A S T R O N O M Y D A T A C E N T R E *****
# Run J-M.'s and Matt's object finding systems... then intersect the
# results.
"""Given a list of directories that have the format triple.ccd look for *.real.astrom and *.NONE.astrom file and update the 'status' line in the process table of the cfeps database"""
from myTaskError import TaskError
if __name__=='__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser=OptionParser()
parser.add_option("--verbose","-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
(opt, dirs)=parser.parse_args()
import os, shutil, sys, string
import MOPdbaccess
mysql=MOPdbaccess.connect('cfeps','cfhls',dbSystem='MYSQL')
cfeps=mysql.cursor()
#*
#* Programmer : <your name>
#*
#* Modification History:
#*
#**** C A N A D I A N A S T R O N O M Y D A T A C E N T R E *****
# Run J-M.'s and Matt's object finding systems... then intersect the
# results.
if __name__=='__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser=OptionParser()
parser.add_option("--verbose","-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple","-t",
action="store",
type="int",
dest="triple",
help="Triple to search")
parser.add_option("--block","-b",
action="store",
default=None,
dest="block",
help="CFEPS Block to retrieve, (eg: 03BQ02)")
parser.add_option("--pointing","-p",
"""Compute the centroids and magnitudes of an input
list of stars and a fits image.
This script is designed to work with MEGAPRIME images from CFHT"""
author="JJ Kavelaars"
version=1.0
import sys
import optik
from optik import OptionParser
if __name__ =='__main__':
parser=OptionParser()
parser.add_option('--image',action='store',
help='image to compute centroids of stars')
parser.add_option('--input',action='store',
help='coo file [in format approriate for iraf.digiphot.daophot.phot coo] ')
parser.add_option('--output',action='store',
help='file with output star coordinates [X,Y,MAG,MERR,ID]')
parser.add_option('--aperture',action='store',
help='phot aperture to use', default=15)
(opt, args)=parser.parse_args()
if not (opt.image and opt.input and opt.output ):
parser.print_help()
sys.exit(0)
return mef_psf
### set the version flag for this program
__Version__ = "$Revision: 1.1 $"
__Id__ = "$Id: ctio_mkpsf.py,v 1.1 2005/01/16 04:56:55 observe Exp $"
if __name__ == "__main__":
### Import some standard python.
import os, sys, string, tempfile, shutil
import optik
from optik import OptionParser
### parse the commandline arguements
parser = OptionParser()
parser.add_option(
"-f", "--file", action="store", type="string", dest="filename", help="create PSF for FILE", metavar="FILE"
)
parser.add_option(
"-e", "--expnum", action="store", type="string", dest="expnum", help="exposure to get from AD", metavar="EXPNUM"
)
parser.add_option(
"-u",
"--update",
action="store_true",
dest="update",
default=0,
help="Update AD with new file? (before possible removal)",
)
parser.add_option(
#* $Date: 2006/01/09 13:36:44 $
#*
#* Programmer : <your name>
#*
#* Modification History:
#*
#**** C A N A D I A N A S T R O N O M Y D A T A C E N T R E *****
# Run J-M.'s and Matt's object finding systems... then intersect the
# results.
if __name__ == '__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser = OptionParser()
parser.add_option("--verbose",
"-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple",
"-t",
action="store",
type="int",
dest="triple",
help="Triple to search")
parser.add_option("--block",
"-b",
action="store",
default=None,
def main():
usage = "usage: %prog [options] sysName [ctp_id | rtpFileName=Run.rtp] [buildMode] [buildOpts]"
dataSource = {"db2": 0, "xml": 1, "ff": 2}
parser = OptionParser(usage)
rtpName = 'Run.rtp'
# sys_class option:
parser.add_option("-c",
"--sys_class",
type="string",
action="store",
dest="sys_class",
default="testing",
help="(scratch | [testing] | production)")
# source options:
parser.add_option("-d",
"--from-database",
action="store_const",
dest="source",
const=dataSource["db2"],
default=dataSource["db2"],
help="look for system in database")
parser.add_option("-x",
"--from-xml",
action="store_const",
dest="source",
const=dataSource["xml"],
help="look for system in xml file")
parser.add_option("-p",
"--from-package",
action="store_const",
dest="source",
const=dataSource["ff"],
help="look for system in force field files")
# force field identifier option (only used if source=package)
parser.add_option("-f",
"--forcefield",
action="store",
dest="forceField",
default="unknown",
help="define force field of system")
# system id option (only used if source=db2)
parser.add_option("-i",
"--system-id",
action="store",
dest="sysId",
default="-1",
help="identify system in db2")
# verbose/quiet options
parser.add_option("-v",
"--verbose",
action="store_true",
dest="verbose",
default="store_false",
help="sets output to be verbose")
parser.add_option("-q",
"--quiet",
action="store_false",
dest="verbose",
help="sets output to be quiet")
(options, args) = parser.parse_args()
buildMode = "Opt"
buildOpts = ''
if len(args) < 1:
parser.error("incorrect number of args")
sysName = args[0]
if len(args) == 2:
rtpName = args[1]
if len(args) == 3:
buildMode = args[2]
if len(args) == 4:
buildOpts = args[3]
if options.verbose:
print("sys_class:", options.sys_class)
print("source:", options.source)
print("rtp file:", rtpName)
print("force field:", options.forceField)
# set xml creation object based on force field setting
creator = None
if options.forceField == 'charmm':
creator = BuildUtils.createXmlForCharmm()
elif options.forceField == 'oplsaa':
creator = BuildUtils.createXmlForOplsaa()
else:
create = BuildUtils.createXml()
sysId = options.sysId
ctpId = -1
if options.source == dataSource["ff"]:
if options.verbose:
print("calling creator.fromSource()")
creator.fromSource(sysName, None, options.verbose)
if options.source == dataSource["xml"] or \
options.source == dataSource["ff"]:
if options.verbose:
print("calling BuildUtils.xml2db2(), BuildUtils.rtp2db2()")
sysId=BuildUtils.xml2db2(sysName + '.' + options.forceField, \
options.verbose)
if options.verbose:
print("sysId =", str(sysId))
if rtpName.isdigit():
ctpId = rtpName
else:
ctpId = BuildUtils.rtp2db2(rtpName, options.verbose)
if options.source == dataSource["xml"] or \
options.source == dataSource["ff"] or \
options.source == dataSource["db2"]:
if options.verbose:
print("calling BuildUtils.db2cpp(), BuildUtils.cpp2exe()")
BuildUtils.db2cpp(
str(sysName) + '.' + str(options.forceField), sysId, ctpId,
options.verbose)
BuildUtils.cpp2exe(
str(sysName) + '.' + str(options.forceField), buildMode, buildOpts,
options.verbose)
return (0)
def _quit():
""" Quit application """
print __appname__ + " terminated"
# Stop SWAP manager
manager.stop()
# Exit application
raise SystemExit
if __name__ == "__main__":
""" Command-line SWAP Device Management Tool """
print __appname__
parser = OptionParser()
# Print version
parser.add_option("--version",
action="store_true",
default="False",
dest="version",
help="Print version number")
# Monitor network activity
parser.add_option("--monitor",
action="store_true",
default="False",
dest="monitor",
help="Monitor SWAP network activity")
# Sniff SWAP network
parser.add_option("--sniff",
action="store_true",
del hdu.header['BSCALE']
del hdu.header['BZERO']
hdu.header['BITPIX'] = pyfits._ImageBaseHDU.ImgCode[
hdu.data.type()]
temp.append(hdu)
return temp
if __name__ == '__main__':
### Import some standard python.
import optik, sys
from optik import OptionParser
### parse the commandline arguements
parser = OptionParser()
parser.add_option("-o",
"--outfile",
action="store",
type="string",
dest="outfile",
help="Name of output MEF file",
metavar="MEF")
parser.add_option("-q",
"--quiet",
action="store_false",
dest="verbose",
default=1,
help="run makepsf/iraf quietly?")
### the left over arguments are assumed to be fits images.
#!/usr/bin/python
import string
import locale
import codecs
import sys
from optik import OptionParser
parser = OptionParser()
parser.add_option("-i", "--input-file", dest="filename",
help="wordlist FILE to parse and evaluate, use - to read form stdin", metavar="FILE")
parser.add_option("-v", "--verbose",
action="store_true", dest="verbose", default=0,
help="print python dictionaries and frequency percentages")
parser.add_option("-l", "--locale", dest="inputlocale", default=locale.getdefaultlocale(),
help="locale to use for selection of valid characters, default is the current locale", metavar="LOCALE")
(options, args) = parser.parse_args()
if options.filename is None:
parser.print_help()
sys.exit()
if options.filename == "-": options.filename = '/dev/stdin'
input = open(options.filename, 'r')
freq = {}
locale.setlocale(locale.LC_ALL, options.inputlocale)
line = input.readline()
total = 0
#while line != "":
# count, word = string.split(line, maxsplit=1)
astrom=filenames[0]+".measure3.cands.astrom"
if os.access(astrom,os.R_OK):
return(1)
else:
return(0)
if __name__=='__main__':
### Must be running as a script
import optik, sys
from optik import OptionParser
parser=OptionParser()
parser.add_option("--verbose","-v",
action="store_true",
dest="verbose",
help="Provide feedback on what I'm doing")
parser.add_option("--triple","-t",
action="store",
type="int",
dest="triple",
help="Triple to search")
parser.add_option("--epoch","-e",
action="store",
default="discovery",
help="Epoch to search. Choose from [discovery|checkup|recovery]"
)
parser.add_option("--block","-b",
