def create_toroidal_mirror(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR=3
self._oe.F_CRYSTAL = 0
self._oe.F_REFRAC = 0
return self
def create_toroidal_grating(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR=3
self._oe.F_GRATING = 1
self._oe.F_REFRAC = 0
return self
def test_1(capsys):
from sys import stderr
import Shadow
beam = Shadow.Beam()
src = Shadow.Source()
assert 2 == src.FDISTR, \
'Basic value for Source'
# Would like to capture stdout, but too complex with extensions.
# Probably extension needs to call a python output method.
beam.genSource(src)
assert 5000 == beam.nrays(), \
'Basic method call for Beam'
oe = Shadow.OE()
oe.D_SPACING = 3
assert 3 == oe.D_SPACING, \
'Basic assignment for OE'
beam.traceOE(oe, 1)
def create_conic_coefficients_refractor(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR=10
self._oe.F_CRYSTAL = 0
self._oe.F_REFRAC = 1
return self
def shadow_src_beam(n_rays=10000,
ran_seed=15829,
dist_type=3,
sigx=4.42e-05,
sigz=2.385e-05,
sigdix=3.52e-05,
sigdiz=2.875e-05,
hdiv1=0.0,
hdiv2=0.0,
vdiv1=0.0,
vdiv2=0.0,
ph_energy=1e3):
"""
This function computes a shadow
beam object from a specified source.
"""
source = Shadow.Source()
beam = Shadow.Beam()
source.NPOINT = n_rays # no. of rays (1 on-axis ray, 4 deviations)
source.ISTAR1 = ran_seed
#source.FSOUR = src_type # source type (0 = point, 3 = Gsn)
#source.WXSOU = wx
#source.WZSOU = wz
source.SIGMAX = sigx
source.SIGMAZ = sigz
source.FDISTR = dist_type
source.SIGDIX = sigdix
source.SIGDIZ = sigdiz
source.F_POLAR = 0
source.HDIV1 = hdiv1
source.HDIV2 = hdiv2
source.VDIV1 = vdiv1
source.VDIV2 = vdiv2
source.IDO_VX = 0
source.IDO_VZ = 0
source.IDO_X_S = 0
source.IDO_Y_S = 0
source.IDO_Z_S = 0
source.F_PHOT = 0
source.PH1 = ph_energy
beam.genSource(source)
return beam
def create_hyperboloid_mirror(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR = 7
self._oe.F_CRYSTAL = 0
self._oe.F_REFRAC = 0
return self
def create_hyperboloid_grating(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR=7
self._oe.F_GRATING = 1
self._oe.F_REFRAC = 0
return self
def create_conic_coefficients_grating(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR=10
self._oe.F_GRATING = 1
self._oe.F_REFRAC = 0
return self
def create_src(cls):
self = cls.__new__(ShadowSource, src=Shadow.Source())
self.src.OE_NUMBER = 0
self.src.FILE_TRAJ = bytes("NONESPECIFIED", 'utf-8')
self.src.FILE_SOURCE = bytes("NONESPECIFIED", 'utf-8')
self.src.FILE_BOUND = bytes("NONESPECIFIED", 'utf-8')
return self
def shadow_ellip_mir_trace(beam,
oe_num=1,
alpha=0.0,
t_source=2850.0,
t_image=0.0,
ssour=2850.0,
simag=900.0,
theta=87.9998043372,
offz=0.0,
mirinfo=0):
"""
This function propagates an input
beam object through an elliptical
mirror element.
beam: shadow beam object
oe_num: optical element sequence number along beamline (1, 2, 3,...)
t_source: source plane distance (drift length before mirror) - assumedly in cm
t_image: image plane distance (drift length after mirror) - assumedly in cm
ssour: distance from source to mirror center [cm] (object side focal distance)
simag: distance from mirror center to second focus [cm] (image side focal distance)
theta: incidence/reflection angle [deg]
offz: mirror offset [cm]
mirinfo: print mirror info; 0 = off, 1 = on
"""
oe = Shadow.OE()
oe.DUMMY = 100.0
oe.FMIRR = 2 # 2: ellipsoidal, 3: toroidal, 10: conic with external coefficients
oe.ALPHA = alpha
oe.FHIT_C = 1
oe.F_EXT = 0 # toggle auto-compute mirror parameters
oe.F_DEFAULT = 0
oe.SSOUR = ssour
oe.SIMAG = simag
oe.THETA = theta
oe.FCYL = 1
oe.FSHAPE = 2
oe.RWIDX1 = 0.05 # added from oasys # X(+) Half Width / Int Maj Ax [m]
oe.RWIDX2 = 0.05 # changed from oasys # X(-) Half Width / Int Maj Ax [m]
oe.RLEN1 = 0.11 # added from oasys # Y(+) Half Width / Int Min Ax [m]
oe.RLEN2 = 0.11 # changed from oasys # Y(-) Half Width / Int Min Ax [m]
oe.T_INCIDENCE = theta
oe.T_REFLECTION = theta
oe.FWRITE = 0
oe.T_IMAGE = t_image # Image plane distance (drift length after mirror)
oe.T_SOURCE = t_source # Source plane distance (drift length before mirror)
oe.F_MOVE = 1
oe.OFFX = 0.0
oe.OFFZ = offz
#oe.Y_ROT = 0
#oe.Z_ROT = 0
if mirinfo == 1:
pkdlog(oe.mirinfo())
beam.traceOE(oe, oe_num)
return beam
def compare_results(do_plot=True, do_assert=True):
if do_plot:
Shadow.ShadowTools.plotxy("minimirr.01",
2,
1,
nbins=101,
nolost=1,
title="Mirror (Python)")
Shadow.ShadowTools.plotxy("mirr.01",
2,
1,
nbins=101,
nolost=1,
title="Mirror (SHADOW)")
Shadow.ShadowTools.plotxy("ministar.01",
1,
3,
nbins=101,
nolost=1,
title="Image (Python)")
Shadow.ShadowTools.plotxy("star.01",
1,
3,
nbins=101,
nolost=1,
title="Image (SHADOW)")
if do_assert:
print("Comparing files mirr.01 and minimirr.01")
minimirr = Shadow.Beam()
minimirr.load("minimirr.01")
mirr = Shadow.Beam()
mirr.load("mirr.01")
assert_almost_equal(minimirr.rays[:, 0:6], mirr.rays[:, 0:6], 2)
print("Comparing files star.01 and ministar.01")
ministar = Shadow.Beam()
ministar.load("ministar.01")
star = Shadow.Beam()
star.load("star.01")
assert_almost_equal(ministar.rays[:, 0:6], star.rays[:, 0:6], 2)
def create_empty_oe(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR = 5
self._oe.F_CRYSTAL = 0
self._oe.F_REFRAC = 2
self._oe.F_SCREEN = 0
self._oe.N_SCREEN = 0
return self
def create_screen_slit(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR = 5
self._oe.F_CRYSTAL = 0
self._oe.F_REFRAC = 2
self._oe.F_SCREEN = 1
self._oe.N_SCREEN = 1
return self
def create_hyperboloid_crystal(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR = 7
self._oe.F_CRYSTAL = 1
self._oe.FILE_REFL = bytes("", 'utf-8')
self._oe.F_REFLECT = 0
self._oe.F_BRAGG_A = 0
self._oe.A_BRAGG = 0.0
self._oe.F_REFRAC = 0
return self
def create_conic_coefficients_crystal(cls):
self = ShadowOpticalElement(oe=Shadow.OE())
self._oe.FMIRR = 10
self._oe.F_CRYSTAL = 1
self._oe.FILE_REFL = bytes("", 'utf-8')
self._oe.F_REFLECT = 0
self._oe.F_BRAGG_A = 0
self._oe.A_BRAGG = 0.0
self._oe.F_REFRAC = 0
return self
def duplicate(self, copy_rays=True, history=True):
beam = Shadow.Beam()
if copy_rays: beam.rays = copy.deepcopy(self._beam.rays)
new_shadow_beam = ShadowBeam(self._oe_number, beam)
new_shadow_beam.setScanningData(self.scanned_variable_data)
if history:
for historyItem in self.history:
new_shadow_beam.history.append(historyItem)
return new_shadow_beam
def _calculate_shadow3_beam_using_preprocessors(jsn):
os.system(
"rm -f start.00 systemfile.dat begin.dat xshundul.plt xshundul.par xshundul.traj xshundul.info xshundul.sha"
)
# epath
commands = "epath\n2\n%f \n%f \n%f \n%d \n1.\nxshundul.par\nxshundul.traj\n1\nxshundul.plt\nexit\n"% \
(jsn["LAMBDAU"],jsn["K"],jsn["E_ENERGY"],101)
_shadow3_commands(commands=commands, input_file="shadow3_epath.inp")
# undul_set
NG_E = jsn["_NG_E"]
# TODO: is seems a bug in shadow3: undul_set must be _NG_E>1 (otherwise nosense)
# but if emin=emaxthe resulting uphot.nml has _NG_E=1
if NG_E == 1: NG_E = 2
commands = "undul_set\n0\n0\n%d \n%d \n%d \nxshundul.traj\n%d\n%f\n%f\n%f\n%f\n0\n1000\nexit\n"% \
(NG_E,jsn["_NG_T"],jsn["_NG_P"],
jsn["NPERIODS"],jsn["_EMIN"],jsn["_EMAX"],jsn["INTENSITY"],1e3*jsn["_MAXANGLE"])
_shadow3_commands(commands=commands, input_file="shadow3_undul_set.inp")
# undul_phot
_shadow3_commands(commands="undul_phot\nexit\n",
input_file="shadow3_undul_phot.inp")
_shadow3_commands(commands="undul_phot_dump\nexit\n",
input_file="shadow3_undul_phot_dump.inp")
# undul_cdf
_shadow3_commands(
commands="undul_cdf\n0\n1\nxshundul.sha\nxshundul.info\nexit\n",
input_file="shadow3_undul_cdf.inp")
# input source
if int(jsn["_FLAG_EMITTANCE(1)"]):
commands = "input_source\n1\n0\n%d \n%d \n0 \n2 \nxshundul.sha\n%g\n%g\n%g\n%d\n%g\n%d\n%d\n%d\n%d\nexit\n"% \
(jsn["NRAYS"],jsn["SEED"],jsn["SX"],jsn["SZ"],jsn["EX"],0,jsn["EZ"],0,3,1,1)
else:
commands = "input_source\n1\n0\n%d \n%d \n0 \n2 \nxshundul.sha\n%g\n%g\n%g\n%d\n%g\n%d\n%d\n%d\n%d\nexit\n"% \
(jsn["NRAYS"],jsn["SEED"],0,0,0,0,0,0,3,1,1)
_shadow3_commands(commands=commands, input_file="shadow3_input_source.inp")
# run source
commands = "source\nsystemfile\nexit\n"
_shadow3_commands(commands=commands, input_file="shadow3_source.inp")
# return shadow3 beam
beam = Shadow.Beam()
beam.load("begin.dat")
return beam
def run_source(oe0, iwrite=False):
# iwrite (1) or not (0) SHADOW files start.xx end.xx star.xx
#Run SHADOW to create the source
if iwrite:
oe0.write("start.00")
beam = Shadow.Beam()
beam.genSource(oe0)
if iwrite:
oe0.write("end.00")
beam.write("begin.dat")
return beam
def define_beamline():
# initialize elements
oe_list = []
oe1 = Shadow.OE()
oe_list.append(oe1)
# Define variables. See https://raw.githubusercontent.com/oasys-kit/shadow3/master/docs/oe.nml
oe1.DUMMY = 100.0
oe1.FMIRR = 3
oe1.FWRITE = 1
oe1.T_IMAGE = 6.0
oe1.T_INCIDENCE = 88.8
oe1.T_REFLECTION = 88.8
return oe_list
def do_something():
global last_power
try:
state = connection.poll()
if state['Power'] != last_power:
logger.warn('Power state changed, sending ' + json.dumps(state))
# not really a warning, but INFO & Debug is too noisy
last_power = state['Power']
# mqtttc.publish(topicName, json.dumps(state), 0)
deviceShadowHandler.shadowUpdate(
Shadow.makeStatePayload("reported", state),
customShadowCallback_Update, 5)
except Exception as e:
logger.info(e)
pass
def shadow_drift_trace(beam, length=900.0):
"""
This function propagates an input
beam object through a drift.
beam: shadow beam object
length: drift length [cm]
"""
oe = Shadow.OE()
oe.DUMMY = 1.0
#oe.set_empty()
oe.FWRITE = 3
oe.T_IMAGE = 0.0
oe.T_SOURCE = length
beam.traceOE(oe, 2)
return beam
def _calculateDataSourceGaussian(self, source_gaussian, in_data):
"""
Calculates output data from input data for a Gaussian source.
"""
adapter = ShadowAdapter()
source = adapter.shadowSourceFromSourceGaussian(source_gaussian)
# TODO: FIX!!!
source.NPOINT = source_gaussian._optical_element.driverSettings(
).valueByName("Number of rays")
beam = Shadow.Beam()
beam.genSource(source)
out_data = self.createData()
out_data.setBeam(beam)
return out_data
def run_shadow_spherical_mirror(beam):
#
# Python script to run shadow3. Created automatically with ShadowTools.make_python_script_from_list().
#
import Shadow
import numpy
# write (1) or not (0) SHADOW files start.xx end.xx star.xx
iwrite = 0
#
# initialize shadow3 source (oe0) and beam
#
oe1 = Shadow.OE()
#
# Define variables. See meaning of variables in:
# https://raw.githubusercontent.com/srio/shadow3/master/docs/source.nml
# https://raw.githubusercontent.com/srio/shadow3/master/docs/oe.nml
#
oe1.DUMMY = 100.0
oe1.FMIRR = 1
oe1.FWRITE = 1
oe1.T_IMAGE = 1.0
oe1.T_INCIDENCE = 41.0
oe1.T_REFLECTION = 41.0
oe1.T_SOURCE = 2.0
#
# run optical element 1
#
print(" Running optical element: %d" % (1))
if iwrite:
oe1.write("start.01")
beam.traceOE(oe1, 1)
if iwrite:
oe1.write("end.01")
beam.write("star.01")
return beam
def setLighting(self):
viz.MainView.getHeadLight().disable()
#viz.MainView.get
self.lightSource = viz.addLight()
self.lightSource.enable()
self.lightSource.position(0, self.ceilingHeight, 0)
self.lightSource.spread(180)
self.lightSource.intensity(2)
### ADD A SHADOW
#SHADOW_RES = 256*10
SHADOW_RES = 100*10
SHADOW_PROJ_POS = (0, self.ceilingHeight, 0)
SHADOW_AREA = (self.roomWidth,self.roomLength)
#Create shadow projector
self.shadowSource = Shadow.ShadowProjector(size=SHADOW_RES,pos=SHADOW_PROJ_POS,area=SHADOW_AREA)
def compare_rays_with_shadow3_beam(raysnew,beam,user_unit_to_m=1.0,do_plot=True,do_assert=False):
import Shadow
from srxraylib.plot.gol import plot_scatter
rays = beam.rays
if do_plot:
plot_scatter(rays[:,1],rays[:,0],title="Trajectory shadow3",show=False)
plot_scatter(raysnew[:,1],raysnew[:,0],title="Trajectory new")
plot_scatter(rays[:,3],rays[:,5],title="Divergences shadow3",show=False)
plot_scatter(raysnew[:,3],raysnew[:,5],title="Divergences new")
plot_scatter(rays[:,0],rays[:,2],title="Real Space shadow3",show=False)
plot_scatter(raysnew[:,0],raysnew[:,2],title="Real Space new")
b = Shadow.Beam()
b.rays = raysnew
Shadow.ShadowTools.histo1(beam,11,ref=23,nolost=1)
Shadow.ShadowTools.histo1(b,11,ref=23,nolost=1)
print("Comparing...")
for i in range(6):
if i <= 2:
fact = 1.0 / user_unit_to_m
else:
fact = 1.0
m0 = (raysnew[:,i]*fact).mean()
m1 = beam.rays[:,i].mean()
print("\ncol %i, mean (new,old,diff/old): "%(i+1),m0,m1,numpy.abs(m0-m1)/numpy.abs(m1))
std0 = (raysnew[:,i]*fact).std()
std1 = beam.rays[:,i].std()
print("col %i, std (new,old,diff/old): "%(i+1),std0,std1,numpy.abs(std0-std1)/numpy.abs(std1))
if do_assert:
if True: # i != 5: # TODO check why it fails!!!
assert((numpy.abs(numpy.abs(m0) -numpy.abs(m1) ) /numpy.abs(m1)) < 15.0)
assert((numpy.abs(numpy.abs(std0) -numpy.abs(std1)) /numpy.abs(std1)) < 0.075)
def shadowSourceFromSourceGaussian(self, source_gaussian):
source = Shadow.Source()
# TODO: FIX!!!
source.FDISTR = 3
source.HDIV1 = 1.0
source.HDIV2 = 1.0
source.VDIV1 = 1.0
source.VDIV2 = 1.0
source.F_PHOT = 0
source.NPOINT = source_gaussian._optical_element.driverSettings(
).valueByName("Number of rays")
source.SIGMAX = source_gaussian.sigmaX()
source.SIGMAZ = source_gaussian.sigmaY()
source.SIGDIX = source_gaussian.sigmaXPrime()
source.SIGDIZ = source_gaussian.sigmaYPrime()
source.PH1 = source_gaussian.energy()
return source
def define_source():
#
# initialize shadow3 source (oe0) and beam
#
oe0 = Shadow.Source()
# Define variables. See https://raw.githubusercontent.com/oasys-kit/shadow3/master/docs/source.nml
oe0.BENER = 6.04
oe0.EPSI_X = 3.8e-07
oe0.EPSI_Z = 3.8e-09
oe0.FDISTR = 4
oe0.FSOURCE_DEPTH = 4
oe0.F_COLOR = 3
oe0.F_PHOT = 0
oe0.HDIV1 = 0.0005
oe0.HDIV2 = 0.0005
oe0.ISTAR1 = 5676561
oe0.NCOL = 0
oe0.NPOINT = 50000
oe0.N_COLOR = 0
oe0.PH1 = 5000.0
oe0.PH2 = 100000.0
oe0.POL_DEG = 0.0
oe0.R_ALADDIN = 25.1772
oe0.R_MAGNET = 25.1772
oe0.SIGDIX = 0.0
oe0.SIGDIZ = 0.0
oe0.SIGMAX = 0.0078
oe0.SIGMAY = 0.0
oe0.SIGMAZ = 0.0036
oe0.VDIV1 = 1.0
oe0.VDIV2 = 1.0
oe0.WXSOU = 0.0
oe0.WYSOU = 0.0
oe0.WZSOU = 0.0
return oe0
def compare_rays_with_shadow3_beam(raysnew,beam,do_plot=True,do_assert=False):
import Shadow
rays = beam.rays
if do_plot:
plot_scatter(rays[:,1],rays[:,0],title="Trajectory shadow3",show=False)
plot_scatter(raysnew[:,1],raysnew[:,0],title="Trajectory new")
plot_scatter(rays[:,3],rays[:,5],title="Divergences shadow3",show=False)
plot_scatter(raysnew[:,3],raysnew[:,5],title="Divergences new")
plot_scatter(rays[:,0],rays[:,2],title="Real Space shadow3",show=False)
plot_scatter(raysnew[:,0],raysnew[:,2],title="Real Space new")
b = Shadow.Beam()
b.rays = raysnew
Shadow.ShadowTools.histo1(beam_shadow3,11,ref=23,nolost=1)
Shadow.ShadowTools.histo1(b,11,ref=23,nolost=1)
if do_assert:
print("Comparing...")
for i in range(6):
if i <= 2:
fact = 100
else:
fact = 1.0
m0 = (raysnew[:,i]*fact).mean()
m1 = beam.rays[:,i].mean()
print("\ncol %d, mean: "%(i+1),m0,m1,numpy.abs(m0-m1)/numpy.abs(m1))
std0 = (raysnew[:,i]*fact).std()
std1 = beam.rays[:,i].std()
print("col %d, std: "%(i+1),std0,std1,numpy.abs(std0-std1)/numpy.abs(std1))
assert((numpy.abs(m0-m1)/numpy.abs(m1)) < 15.0)
assert((numpy.abs(std0-std1)/numpy.abs(std1)) < 0.05)
def define_beamline():
# initialize elements
oe_list = []
oe1 = Shadow.OE()
oe_list.append(oe1)
# Define variables. See https://raw.githubusercontent.com/oasys-kit/shadow3/master/docs/oe.nml
oe1.DUMMY = 100.0
oe1.FHIT_C = 1
oe1.FILE_REFL = b'/users/srio/OASYS1.2/shadow4tests/shadow4tests/oasys_workspaces/SiC.dat'
oe1.FWRITE = 1
oe1.F_REFLEC = 1
oe1.RLEN1 = 5e-05
oe1.RLEN2 = 5e-05
oe1.RWIDX1 = 2e-05
oe1.RWIDX2 = 2e-05
oe1.T_IMAGE = 6.0
oe1.T_INCIDENCE = 88.8
oe1.T_REFLECTION = 88.8
return oe_list
def __init__(self, passwd):
self.data = Shadow(passwd)
def trace_shadow(beam):
#
# Python script to run shadow3. Created automatically with ShadowTools.make_python_script_from_list().
#
import Shadow
import numpy
# write (1) or not (0) SHADOW files start.xx end.xx star.xx
iwrite = 0
#
oe1 = Shadow.OE()
oe2 = Shadow.OE()
oe1.DUMMY = 100.0
oe1.FHIT_C = 1
oe1.FWRITE = 1
oe1.RLEN1 = 0.05
oe1.RLEN2 = 0.05
oe1.RWIDX1 = 0.005
oe1.RWIDX2 = 0.005
oe1.T_IMAGE = 1.0
oe1.T_INCIDENCE = 65.0
oe1.T_REFLECTION = 65.0
oe1.T_SOURCE = 2.0
oe2.ALPHA = 90
oe2.DUMMY = 100.0
oe2.FHIT_C = 1
oe2.FMIRR = 4
oe2.FWRITE = 1
oe2.RLEN1 = 0.1
oe2.RLEN2 = 0.1
oe2.RWIDX1 = 0.01
oe2.RWIDX2 = 0.01
oe2.T_IMAGE = 2.0
oe2.T_INCIDENCE = 28.0
oe2.T_REFLECTION = 28.0
oe2.T_SOURCE = 5.0
#
# run optical element 1
#
print(" Running optical element: %d" % (1))
if iwrite:
oe1.write("start.01")
beam.traceOE(oe1, 1)
if iwrite:
oe1.write("end.01")
beam.write("star.01")
#
# run optical element 2
#
print(" Running optical element: %d" % (2))
if iwrite:
oe2.write("start.02")
beam.traceOE(oe2, 2)
if iwrite:
oe2.write("end.02")
beam.write("star.02")
return beam
class Password():
def __init__(self, passwd):
self.data = Shadow(passwd)
def list(self):
info = self.data.getInfo()
for row in info:
#print row['id'] ,row['name'],row['user'],row['password']
print row['name']
def imp(self):
path = raw_input("Enter the path to database (/home/xpto/chrome_db.sql)> ")
self.data.importDb(path)
print 'DB imported with success!'
def ins(self):
name = raw_input("Enter the site or name> ")
user = raw_input("Enter the username> ")
passwd = getpass.getpass("Enter the password> ")
passwd1 = getpass.getpass("ReEnter the password> ")
if passwd == passwd1:
get = self.data.addInfo(name, user, passwd)
print get
print '___________________________________'
print 'Insert with success'
print '___________________________________'
else:
print '___________________________________'
print 'Password miss match \n'
print '___________________________________'
self.ins()
def search(self):
name = raw_input("Enter the name to search> ")
get = self.data.searchInfo(name)
print "id \t site \t\t\t\t\t\t\t\t\t user"
for row in get:
#print row['id'], row['name'], row['user'], row['password']
print "%i \t %s \t\t\t\t\t\t\t\t\t %s " % (row['id'], row['name'], row['user'])
#print row['name']
def options(self):
print '___________________________________'
print '1 - Import Chrome database'
print '2 - List all information'
print '3 - Insert new information'
print '4 - Search information'
print '5 - Exit'
print '___________________________________'
def Menu(self):
os.system('clear')
while True:
self.options()
value = raw_input("Make a selection> ")
if '1' in value:
self.imp()
#self.runSetMenu()
#os.system('clear')
os.ch
elif '2' in value:
self.list()
#os.system('clear')
elif '3' in value:
self.ins()
#self.deleteSetMenu()
#os.system('clear')
elif '4' in value:
#self.createSetMenu()
self.search()
#os.system('clear')
elif '5' in value:
print 'Good-bye'
quit()
else:
os.system('clear')
print 'Invalid menu choice.'
def run(self):
print 'Initializing'
self.Menu()
