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
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)
# for c in word:
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",
action="store",
default=None,
dest="pointing",
help="CFEPS POINTING to retrieve, (eg: 03BQ02)")
(opt, file_ids) = parser.parse_args()
import os, shutil
import MOPdbaccess, MOPfits
mysql = MOPdbaccess.connect('cfeps', 'cfhls', dbSystem='MYSQL')
if not opt.triple and not opt.block:
parser.print_help()
sys.exit("\n\n You must specify either a triple or block\n")
cfeps = mysql.cursor()
if not opt.triple:
sql = """SELECT DISTINCT(t.id)
FROM triples t JOIN checkup d ON t.id=d.triple
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",
action="store",
default=-1,
type="int",
dest="ccd",
help="Provide feedback on what I'm doing")
(opt, file_ids)=parser.parse_args()
import os, shutil
if os.getenv('_CONDOR_SCRATCH_DIR') != None: os.chdir(os.getenv('_CONDOR_SCRATCH_DIR'))
import MOPdbaccess
mysql=MOPdbaccess.connect('cfeps','cfhls',dbSystem='MYSQL')
cfeps=mysql.cursor()
if not opt.triple:
sql="""SELECT DISTINCT(t.id)
FROM triples t JOIN discovery d ON t.id=d.triple
JOIN bucket.association a ON t.pointing=a.pointing
JOIN bucket.blocks b ON a.expnum=b.expnum
WHERE b.qname LIKE '%s'""" % ( opt.block, )
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)
def centroid(image,input,output):
"""Compute the centroids and magnitudes of a bunch sources detected on CFHT-MEGAPRIME images"""
print "Centroiding stars"
print "IMAGE: %s " % (opt.image,)
print "COORDINATES: %s " % ( opt.input,)
print "RESULTS: %s" % ( opt.output, )
from pyraf import iraf
from pyraf.irafpar import IrafParList
import pyfits
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()
foreach dir in dirs:
[triple.ccd] = dirs.split('.')
sql="""SELECT distinct(t.id),m.ccd
FROM triples t
JOIN %s d ON t.id=d.triple
JOIN block_pointing b ON b.pointing=t.pointing
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))
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))
# Or address unitary registers
# Register id
parser.add_option("-r",
"--regid",
type="int",
dest="regId",
help="Register ID")
# Register value
parser.add_option("-v",
"--value",
type="string",
dest="value",
help="Register value)")
(options, args) = parser.parse_args()
# Dispatch commands
if options.version == True:
print __version__
raise SystemExit
try:
# Start SWAP manager tool
manager = SwapManager(options.sniff, options.monitor)
# Configuration commands
if options.config == True:
listCfgRegs = None
setCustomReg = False
# Device passed as argument?
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)
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',
default=0)
parser.add_option('-w','--stopwords', action='store',type='string',
dest='extra_use_stopwords', help='name of stopword file')
parser.add_option('-P','--parser', action='store', type='string',
dest='extra_use_parser',default='PyQueryParser',
help='parser name')
parser.add_option('-X','--prof', action='store_true',
dest='prof',default=0,
help='profiling on/off')
options,args = parser.parse_args()
class extra:
def __init__(self):
self._keys = list()
def set(self, k, v):
setattr(self, k, v)
self._keys.append(k)
def keys(self): return self._keys
E = extra()
for k in dir(options):
if k.startswith('extra_'):
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>")
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)
def centroid(image, input, output):
"""Compute the centroids and magnitudes of a bunch sources detected on CFHT-MEGAPRIME images"""
print "Centroiding stars"
print "IMAGE: %s " % (opt.image, )
print "COORDINATES: %s " % (opt.input, )
print "RESULTS: %s" % (opt.output, )
