class Test_Pads(EBL_Polygons): """Makes test pad structure for pads""" def _default_plot_sep(self): return False @private_property def base_name(self): return "Test_Pads" def _default_color(self): return "blue" contact_width = Float(125.0e-6).tag(unit="um", desc="width of contact") contact_height = Float(170.0e-6).tag(unit="um", desc="height of contact") bridge_gap_x = Float(20.0e-6).tag( unit="um", desc="horizontal gap between testpad electrodes") bridge_gap_y = Float(50.0e-6).tag( unit="um", desc="vertical gap between testpad electrodes") testpad_width = Float(400.0e-6).tag(unit="um", desc="overall width of testpad") testpad_height = Float(450.0e-6).tag(unit="um", desc="overall height of testpad") tp_bond_pad = Float(100.0e-6).tag(unit="um", desc="bonding area of testpad") @private_property def polylist(self): """makes 4 branched testpad through reflections""" self.verts = [] reset_property(self, "_s_testpad_TL") self.verts.extend(self._s_testpad_TL) self.verts.extend(horiz_refl(self._s_testpad_TL)) self.verts.extend(vert_refl(self._s_testpad_TL)) self.verts.extend(horizvert_refl(self._s_testpad_TL)) return self.verts @private_property def _s_testpad_TL(self): """returns top left part of test pad""" return sP([(-self.testpad_width / 2.0, -self.testpad_height / 2.0), (-self.testpad_width / 2.0, -self.testpad_height / 2.0 + self.tp_bond_pad), (-self.contact_width / 2.0, -self.contact_height / 2.0), (-self.contact_width / 2.0, -self.bridge_gap_y / 2.0), (-self.bridge_gap_x / 2.0, -self.bridge_gap_y / 2.0), (-self.bridge_gap_x / 2.0, -self.contact_height / 2.0), (-self.testpad_width / 2.0 + self.tp_bond_pad, -self.testpad_height / 2.0)])
class Fillet(Operation): """ Applies fillet operation to the first child shape. Attributes ---------- shape: String The fillet shape type apply radius: Float Radius of the fillet. Must be less than the face width. operations: List of edges, optional List of edges to apply the operation to. If not given all edges will be used. Used in conjunction with the `topology.edges` attribute. Examples -------- Fillet: #: Fillet the first 4 edges of the box (left side) operations = [e for i, e in enumerate(box.topology.edges) if i < 4] radius = 0.1 Box: box: pass """ #: Reference to the implementation control proxy = Typed(ProxyFillet) #: If True, don't apply the fillet (for debugging) disabled = d_(Bool()) #: Fillet shape type shape_type = d_(Enum('rational', 'angular', 'polynomial')).tag( view=True, group='Fillet') #: Radius of fillet radius = d_(Float(1, strict=False)).tag(view=True, group='Fillet') #: Edges to apply fillet to and parameters #: Leave blank to use all edges of the shape operations = d_(List()).tag(view=True, group='Fillet') @observe('shape_type', 'radius', 'operations', 'disabled') def _update_proxy(self, change): super(Fillet, self)._update_proxy(change)
class Test(Atom): a=SProperty(cached=False) c=Float() #b=TProperty(cached=False)#.tag(blah=3) #_b=Value() d=Enum("single", "double") @t_property(cached=False) def b(self, d): return {"single" : 3, "double" : 4}[d] @a.getter def _get_a(self, c): return 2*c @a.setter def _get_c(self, a): return a/2
class Page(SQLModel): title = Str().tag(length=60) status = Enum("preview", "live") body = Str().tag(type=sa.UnicodeText()) author = Instance(User) if DATABASE_URL.startswith("postgres"): images = List(Instance(Image)) related = List(ForwardInstance(lambda: Page)).tag(nullable=True) tags = List(str) visits = BigInt() date = Instance(date) last_updated = Instance(datetime) rating = Instance(Decimal) ranking = Float().tag(name="order") # A bit verbose but provides a custom column specification data = Instance(object).tag(column=sa.Column("data", sa.LargeBinary()))
class FloatingActionButton(ImageButton): """ A simple control for displaying a floating button with an Image. """ #: A reference to the proxy object. proxy = Typed(ProxyFloatingActionButton) #: Size of the button. Auto will resize to mini for small screens size = d_(Enum('normal', 'auto', 'mini')) #: Elevation to use elevation = d_(Float()) #: Color of the ripple touch effect ripple_color = d_(Unicode()) #: Show or hide the button show = d_(Bool(True))
class tSpy(Spy): a = Float().tag(unit="A", unit_factor=10.0, label="Current", no_spacer=True, show_value=True) b = Unicode() c = Unicode().tag(no_spacer=True, spec="multiline") d = Int().tag(unit="A", unit_factor=10, label="Current", show_value=True) e = Enum("arg") @Callable def g(self): print self print "ran g"
class FFTChannelPlot(ChannelPlot): time_span = d_(Float(1)) waveform_averages = d_(Int(1)) window = d_(Enum('hamming', 'flattop')) apply_calibration = d_(Bool(True)) _x = Typed(np.ndarray) _buffer = Typed(SignalBuffer) def _default_name(self): return self.source_name + '_fft_plot' def _observe_source(self, event): if self.source is not None: self.source.add_callback(self._append_data) self.source.observe('fs', self._cache_x) self._update_buffer() self._cache_x() def _update_buffer(self, event=None): self._buffer = SignalBuffer(self.source.fs, self.time_span) def _append_data(self, data): self._buffer.append_data(data) self.update() def _cache_x(self, event=None): if self.source.fs: time_span = self.time_span / self.waveform_averages self._x = get_x_fft(self.source.fs, time_span) def update(self, event=None): if self._buffer.get_time_ub() >= self.time_span: data = self._buffer.get_latest(-self.time_span, 0) psd = util.psd(data, self.source.fs, self.window, waveform_averages=self.waveform_averages) if self.apply_calibration: db = self.source.calibration.get_db(self._x, psd) else: db = util.db(psd) if self._x.shape == db.shape: deferred_call(self.plot.setData, self._x, db)
class DrawerLayout(ViewGroup): """ A simple control for displaying a drawer """ #: List of opened drawers opened = d_(List(View)) #: Drawer width drawer_width = d_(Int(200)) #: Title of drawer title = d_(Unicode()) #: Gravity of title title_gravity = d_(Int()) #: Elevation drawer_elevation = d_(Float()) #: Set lock mode lock_mode = d_(Enum('unlocked', 'locked_closed', 'locked_open')) #: Set a color to use for the scrim that obscures primary content #: while a drawer is open. scrim_color = d_(Unicode()) #: Statusbar background color status_bar_background_color = d_(Unicode()) #: A reference to the ProxyLabel object. proxy = Typed(ProxyDrawerLayout) # ------------------------------------------------------------------------- # Observers # ------------------------------------------------------------------------- @observe('opened', 'drawer_width', 'title', 'title_gravity', 'drawer_elevation', 'drawer_lock_mode', 'scrim_color', 'status_bar_background_color') def _update_proxy(self, change): """ An observer which sends the state change to the proxy. """ # The superclass implementation is sufficient. super(DrawerLayout, self)._update_proxy(change)
class PointCalibration(Calibration): frequency = Typed(np.ndarray).tag(metadata=True) sensitivity = Typed(np.ndarray).tag(metadata=True) fixed_gain = Float(0).tag(metadata=True) def __init__(self, frequency, sensitivity, fixed_gain=0, source=None): if np.isscalar(frequency): frequency = [frequency] if np.isscalar(sensitivity): sensitivity = [sensitivity] self.frequency = np.array(frequency) self.sensitivity = np.array(sensitivity) self.fixed_gain = fixed_gain if source is not None: self.source = Path(source) def get_sens(self, frequency): if np.iterable(frequency): return np.array([self._get_sens(f) for f in frequency]) else: return self._get_sens(frequency) def _get_sens(self, frequency): try: i = np.flatnonzero(np.equal(self.frequency, frequency))[0] except IndexError: log.debug('Calibrated frequencies are %r', self.frequency) m = 'Frequency {} not calibrated'.format(frequency) raise CalibrationError(m) return self.sensitivity[i]-self.fixed_gain @classmethod def from_psi_chirp(cls, folder, output_gain=None, **kwargs): filename = os.path.join(folder, 'chirp_sensitivity.csv') sensitivity = pd.io.parsers.read_csv(filename) if output_gain is None: output_gain = sensitivity.loc[:, 'hw_ao_chirp_level'].max() m = sensitivity['hw_ao_chirp_level'] == output_gain mic_freq = sensitivity.loc[m, 'frequency'].values mic_sens = sensitivity.loc[m, 'sens'].values source = 'psi_chirp', folder, output_gain return cls(mic_freq, mic_sens, source=source, **kwargs)
class Fig2e(Slave): """ Fig. 2e, cross section through the zoomed-in fluxmap ("zcs" for "zoomed cross section")""" S11_offset = Float(-31.12).tag( desc= "Background S11 value, chosen to put the flat part of the detuned S11 (panel a) curve at 0dB" ) data = Dict() det_freq = Coerced(ndarray, [0], coercer=array).tag(plot=True) det_S11 = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq") det_phase = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq") S11 = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq") freq = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq") phase = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq") yoko = Coerced(ndarray, [0], coercer=array).tag(plot=True, xdata="det_freq")
class DisplayText(DisplayItem): """ Add text to the 3d display. """ #: Reference to the implementation control proxy = Typed(ProxyDisplayText) #: Text to display text = d_(Str()) #: Font size size = d_(Float(12)) #: Font family font = d_(Str()) @observe('text', 'size', 'font') def _update_proxy(self, change): super()._update_proxy(change)
class Fillet(LocalOperation): """ Applies fillet to the first child shape""" #: Reference to the implementation control proxy = Typed(ProxyFillet) #: Fillet shape type shape = d_(Enum('rational', 'angular', 'polynomial')).tag(view=True, group='Fillet') #: Radius of fillet radius = d_(Float(1, strict=False)).tag(view=True, group='Fillet') #: Edges to apply fillet to #: Leave blank to use all edges of the shape edges = d_(ContainerList(object)).tag(view=True, group='Fillet') @observe('shape', 'radius', 'edges') def _update_proxy(self, change): super(Fillet, self)._update_proxy(change)
class Edge(LogicalChannel): ''' Defines an arc/directed edge between qubit vertices. If a device supports bi-directional connectivity, that is represented with two independent Edges. An Edge is also effectively an abstract channel, so it carries the same properties as a Qubit channel. ''' # allow unicode in source and target so that we can store a label or an object source = Instance((unicode, Qubit)) target = Instance((unicode, Qubit)) pulseParams = Dict( default={ 'length': 20e-9, 'amp': 1.0, 'phase': 0.0, 'shapeFun': PulseShapes.gaussian, 'cutoff': 2, 'dragScaling': 0, 'sigma': 5e-9, 'riseFall': 20e-9 }) gateChan = Instance((unicode, LogicalMarkerChannel)) frequency = Float(0.0).tag( desc='modulation frequency of the channel (can be positive or negative)' ) def __init__(self, **kwargs): super(Edge, self).__init__(**kwargs) if self.gateChan is None: self.gateChan = LogicalMarkerChannel(label=kwargs['label'] + '-gate') def isforward(self, source, target): ''' Test whether (source, target) matches the directionality of the edge. ''' nodes = (self.source, self.target) if (source not in nodes) or (target not in nodes): raise ValueError('One of {0} is not a node in the edge'.format( (source, target))) if (self.source, self.target) == (source, target): return True else: return False
class ThruSections(Operation): """ An operation that extrudes a shape by means of going through a series of profile sections along a spline or path. Attributes ---------- solid: Bool If True, build a solid otherwise build a shell. ruled: Bool If False, smooth out the surfaces using approximation precision: Float, optional The precision to use for approximation. Examples -------- See examples/thru_sections.enaml """ #: Reference to the implementation control proxy = Typed(ProxyThruSections) #: isSolid is set to true if the construction algorithm is required #: to build a solid or to false if it is required to build a shell #: (the default value), solid = d_(Bool(False)).tag(view=True, group='Through Sections') #: ruled is set to true if the faces generated between the edges #: of two consecutive wires are ruled surfaces or to false #: (the default value) #: if they are smoothed out by approximation ruled = d_(Bool(False)).tag(view=True, group='Through Sections') #: pres3d defines the precision criterion used by the approximation #: algorithm; #: the default value is 1.0e-6. Use AddWire and AddVertex to define #: the successive sections of the shell or solid to be built. precision = d_(Float(1e-6)).tag(view=True, group='Through Sections') @observe('solid', 'ruled', 'precision') def _update_proxy(self, change): super(ThruSections, self)._update_proxy(change)
class Fillet(LocalOperation): """ Applies fillet operation to the first child shape. Attributes ---------- shape: String The fillet shape type apply radius: Float Radius of the fillet. Must be less than the face width. edges: List of edges, optional List of edges to apply the operation to. If not given all edges will be used. Used in conjunction with the `shape_edges` attribute. Examples -------- Fillet: #: Fillet the first 4 edges of the box (left side) edges = [e for i, e in enumerate(box.shape_edges) if i < 4] radius = 0.1 Box: box: pass """ #: Reference to the implementation control proxy = Typed(ProxyFillet) #: Fillet shape type shape = d_(Enum('rational', 'angular', 'polynomial')).tag(view=True, group='Fillet') #: Radius of fillet radius = d_(Float(1, strict=False)).tag(view=True, group='Fillet') #: Edges to apply fillet to #: Leave blank to use all edges of the shape edges = d_(ContainerList(object)).tag(view=True, group='Fillet') @observe('shape', 'radius', 'edges') def _update_proxy(self, change): super(Fillet, self)._update_proxy(change)
class Parabola(Edge): """ Creates a Parabola with its local coordinate system given by the `position` and `direction` and it's focal length `focal_length`. Attributes ---------- focal_length: Float The focal length of the parabola. Notes ----- The XDirection of A2 defines the axis of symmetry of the parabola. The YDirection of A2 is parallel to the directrix of the parabola. The Location point of A2 is the vertex of the parabola Raises ConstructionError if Focal < 0.0 Raised if Focal < 0.0. Examples --------- Wire: Parabola: focal_length = 10 """ proxy = Typed(ProxyParabola) #: Focal length of the parabola focal_length = d_(Float(1, strict=False)).tag(view=True) @property def start(self): return coerce_point(self.proxy.curve.StartPoint()) @property def end(self): return coerce_point(self.proxy.curve.EndPoint()) @observe('focal_length') def _update_proxy(self, change): super()._update_proxy(change)
class Revol(Shape): """ A Revol creates a shape by revolving a profile about an axis. Attributes ---------- shape: Shape Shape to revolve. If not given, the first child will be used. angle: Float Angle to revolve (in radians) the base profile. copy: Bool Make a copy of the referenced shape. Examples -------- # This creates a cone of radius 4 and height 5. Revol: Wire: Segment: Looper: iterable = [(0,0,0), (0,2,5), (0,5,0), (0,0,0)] Point: position = loop_item """ #: Proxy shape proxy = Typed(ProxyRevol) #: Shape to build prism from shape = d_(Instance(Shape)).tag(view=True) #: Angle to revolve angle = d_(Float(0, strict=False)).tag(view=True) #: Copy the surface copy = d_(Bool(False)).tag(view=True) @observe('shape', 'angle', 'copy') def _update_proxy(self, change): super(Revol, self)._update_proxy(change)
class PiezoChannel(Prop): version = '2014.04.06' setServo = Typed(BoolProp) setPosition = Typed(FloatProp) readAxis = Str() readServo = Member() readPosition = Float() def __init__(self, name, experiment, description=''): super(PiezoChannel, self).__init__(name, experiment, description) self.readServo = False self.setServo = BoolProp('setServo', self.experiment, '', 'False') self.setPosition = FloatProp('setPosition', self.experiment, '', '0') self.readAxis = '' self.readServo = False self.readPosition = float('nan') self.properties += [ 'version', 'setServo', 'setPosition', 'readAxis', 'readServo', 'readPosition' ]
class SleepTask(SimpleTask): """Simply sleeps for the specified amount of time. Wait for any parallel operation before execution. """ time = Float().tag(pref=True) def __init__(self, **kwargs): super(SleepTask, self).__init__(**kwargs) self.make_wait() def process(self): """ """ sleep(self.time) def check(self, *args, **kwargs): """ """ return True, {}
class Revol(Shape): #: Proxy shape proxy = Typed(ProxyRevol) #: Shape to build prism from shape = d_(Instance(Shape)).tag(view=True) #: Angle to revolve angle = d_(Float(0, strict=False)).tag(view=True) #: Copy the surface copy = d_(Bool(False)).tag(view=True) @observe( 'shape', 'angle', 'copy', ) def _update_proxy(self, change): super(Revol, self)._update_proxy(change)
class Fig2a(Slave): plot_all = Bool(False) """ Fig. 2a, the IDT background trace with qubit off resonance ("det" for "detuned").""" S11_offset = Float(-31.12).tag( desc= "Background S11 value, chosen to put the flat part of the detuned S11 (panel a) curve at 0dB" ) det_freq = Coerced(ndarray, [0], coercer=array).tag(plot=True, plot_label='Frequency (GHz)') det_S11 = Coerced(ndarray, [0], coercer=array).tag( plot=True, xdata="det_freq", plot_label='S11 with qubit detuned (dB)') det_S11_avg = Coerced(ndarray, [0], coercer=array).tag( plot=True, xdata="det_freq", plot_label='S11 with qubit detuned (dB)') def __init__(self, **kwargs): super(Fig2a, self).__init__(**kwargs) for key in self.members().keys(): if self.get_tag(key, 'plot', self.plot_all): self.boss.plottables.append(key)
class ApplyMagFieldAndDropTask(InstrumentTask): """Use a supraconducting magnet to apply a magnetic field. Parallel task. """ # Target magnetic field (dynamically evaluated) field = Unicode().tag(pref=True, feval=validators.SkipLoop(types=numbers.Real)) # Rate at which to sweep the field. rate = Float(0.01).tag(pref=True) parallel = set_default({'activated': True, 'pool': 'instr'}) database_entries = set_default({'field': 0.01}) def check_for_interruption(self): """Check if the user required an interruption. """ return self.root.should_stop.is_set() def perform(self, target_value=None): """Apply the specified magnetic field. """ # make ready if (self.driver.owner != self.name or not self.driver.check_connection()): self.driver.owner = self.name driver = self.driver if driver.heater_state == 'Off': raise ValueError(cleandoc(''' Switch heater must be on''')) if target_value is None: target_value = self.format_and_eval_string(self.field) driver.field_sweep_rate = self.rate driver.target_field = target_value driver.activity = 'To set point' self.write_in_database('field', target_value)
class InterpCalibration(Calibration): ''' Use when calibration is not flat (i.e., uniform) across frequency. Parameters ---------- frequency : array-like, Hz Calibrated frequencies (in Hz) sensitivity : array-like, dB(V/Pa) Sensitivity at calibrated frequency in dB(V/Pa) assuming 1 Vrms and 0 dB gain. If you have sensitivity in V/Pa, just pass it in as 20*np.log10(sens). fixed_gain : float Fixed gain of the input or output. The sensitivity is calculated using a gain of 0 dB, so if the input (e.g. a microphone preamp) or output (e.g. a speaker amplifier) adds a fixed gain, this needs to be factored into the calculation. For input calibrations, the gain must be negative (e.g. if the microphone amplifier is set to 40 dB gain, then provide -40 as the value). ''' frequency = Typed(np.ndarray).tag(metadata=True) sensitivity = Typed(np.ndarray).tag(metadata=True) fixed_gain = Float(0).tag(metadata=True) _interp = Callable() def __init__(self, frequency, sensitivity, fixed_gain=0, source=None): self.frequency = np.asarray(frequency) self.sensitivity = np.asarray(sensitivity) self.fixed_gain = fixed_gain self._interp = interp1d(frequency, sensitivity, 'linear', bounds_error=False) if source is not None: self.source = Path(source) def get_sens(self, frequency): # Since sensitivity is in dB(V/Pa), subtracting fixed_gain from # sensitivity will *increase* the sensitivity of the system. return self._interp(frequency)-self.fixed_gain
class SubWaferCoord(Atom): wafer_type = Enum("Full") diameter = Float(4).tag(unit="in", desc="wafer diameter in inches") chip_size = Int(5000).tag(desc="size of chip in microns", unit=" um") gap_size = Int(5000).tag(desc="gap from center of wafer", unit=" um") bad_coord_type = Enum("quarter wafer", "full wafer", "none") randomize = Enum(True, False) Px = Int(4000) Py = Int(40000) Qx = Int(40000) Qy = Int(4000) @cached_property def x_offset(self): return 0 @cached_property def y_offset(self): return 0 @cached_property def N_chips(self): return 1 @cached_property def step_size(self): return 0 @property def GLM(self): return [self.Px, self.Py, self.Qx, self.Qy] @cached_property def view_window(self): with imports(): from taref.ebl.wafer_coords_e import WaferCoordsView view = WaferCoordsView(wc=self) return view
class ScatterFormat(LineFormat): clt=Typed(PathCollection) marker = Enum(*markers_tuple) marker_size = Float(1.0).tag(former="s") facecolor=Enum(*colors_tuple[1:]).tag(former="facecolor") edgecolor=Enum(*colors_tuple[1:]).tag(former="edgecolor") @plot_observe("facecolor", "edgecolor", update_legend=True) def scatter_update(self, change): self.plot_set(change["name"]) @plot_observe("marker_size", update_legend=True) def marker_size_update(self, change): self.clt.set_sizes([self.marker_size]) @plot_observe("marker", update_legend=True) def marker_update(self, change): self.scatter_plot() def _default_plot_type(self): return "scatter" def scatter_plot(self, *args, **kwargs): kwargs=process_kwargs(self, kwargs) self.remove_collection() if len(args)==1: self.ydata=args[0] self.xdata=arange(len(self.ydata)) elif len(args)==2: self.xdata=args[0] self.ydata=args[1] self.clt=self.plotter.axes.scatter(self.xdata, self.ydata, **kwargs) self.do_autolim() @transformation def scatter2line(self): lf=Line2DFormat(plot_name=self.plot_name, plotter=self.plotter) lf.line_plot(self.xdata, self.ydata) return lf
class Offset(Operation): #: Reference to the implementation control proxy = Typed(ProxyOffset) #: Offset offset = d_(Float(1, strict=False)).tag(view=True, group='Offset') #: Offset mode offset_mode = d_(Enum('skin', 'pipe', 'recto_verso')).tag(view=True, group='Offset') #: Intersection intersection = d_(Bool(False)).tag(view=True, group='Offset') #: Join type join_type = d_(Enum('arc', 'tangent', 'intersection')).tag(view=True, group='Offset') @observe('offset', 'offset_mode', 'intersection', 'join_type') def _update_proxy(self, change): super(Offset, self)._update_proxy(change)
class Lyzer(Agent): base_name="lyzer" fridge_atten=Float(60) fridge_gain=Float(40) @tag_property() def net_loss(self): return self.fridge_gain-self.fridge_atten+self.rt_gain-self.rt_atten rd_hdf=Typed(Read_HDF5) save_folder=Typed(Folder) save_file=Typed(Save_TXT) save_code=Typed(Save_TXT) read_data=Callable().tag(sub=True) def _default_save_folder(self): return Folder(base_dir="/Users/thomasaref/Dropbox/Current stuff/test_data/tex_processed", main_dir="overall") def _default_save_file(self): return Save_TXT(folder=self.save_folder, file_name="file_names", file_suffix=".txt", fixed_mode=True, write_mode="a") def _default_save_code(self): return Save_TXT(folder=self.save_file.folder, file_name=self.save_file.file_name+"_code", file_suffix=".py", fixed_mode=True) def save_plots(self, pl_list): names="\n".join([pl.fig_name for pl in pl_list]) #self.save_file.file_name=self.name+"_file_names" self.save_file.save(names, write_mode="w", flush_buffer=True) for pl in pl_list: pl.savefig(self.save_folder.dir_path_d, pl.fig_name) rt_atten=Float(40) rt_gain=Float(23*2) offset=Float(-0.035) flux_factor=Float(0.2925) def _default_offset(self): return self.qdt.offset def _default_flux_factor(self): return self.qdt.flux_factor comment=Unicode().tag(read_only=True, spec="multiline")
class ThruSections(Operation): #: Reference to the implementation control proxy = Typed(ProxyThruSections) #: isSolid is set to true if the construction algorithm is required #: to build a solid or to false if it is required to build a shell (the default value), solid = d_(Bool(False)).tag(view=True, group='Through Sections') #: ruled is set to true if the faces generated between the edges #: of two consecutive wires are ruled surfaces or to false (the default value) #: if they are smoothed out by approximation ruled = d_(Bool(False)).tag(view=True, group='Through Sections') #: pres3d defines the precision criterion used by the approximation algorithm; #: the default value is 1.0e-6. Use AddWire and AddVertex to define #: the successive sections of the shell or solid to be built. precision = d_(Float(1e-6)).tag(view=True, group='Through Sections') @observe('solid', 'ruled', 'precision') def _update_proxy(self, change): super(ThruSections, self)._update_proxy(change)
class Qubit(LogicalChannel): ''' The main class for generating qubit pulses. Effectively a logical "QuadratureChannel". ''' pulse_params = Dict( default={ 'length': 20e-9, 'piAmp': 1.0, 'pi2Amp': 0.5, 'shape_fun': PulseShapes.gaussian, 'cutoff': 2, 'drag_scaling': 0, 'sigma': 5e-9 }) gate_chan = Instance((str, LogicalMarkerChannel)) frequency = Float(0.0).tag( desc='modulation frequency of the channel (can be positive or negative)' ) def __init__(self, **kwargs): super(Qubit, self).__init__(**kwargs)
class HttpResponse(Atom): """ The response object returned to an AsyncHttpClient fetch callback. It is based on the the tornado HttpResponse object. """ #: Request that created this response request = Instance(HttpRequest) #: Numeric HTTP status code code = Int() #: Reason phrase for the status code reason = Unicode() #: Response headers list of strings headers = List() #: Result success ok = Bool() #: Response body #: Note: if a streaming_callback is given to the request #: then this is NOT used and will be empty body = Unicode() #: Size content_length = Int() #: Error message error = Instance(HttpError) #: Response headers headers = List() #: Progress progress = Int() #: Done time request_time = Float()