|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
JsonFactory
used for constructing
JSON parser (JsonParser
)
and generator
(JsonParser
)
instances.
See:
Description
| Interface Summary | |
|---|---|
| FormatSchema | Simple tag interface used to mark schema objects that are used by some
JsonParser and JsonGenerator implementations to further
specify structure of expected format. |
| PrettyPrinter | Interface for objects that implement pretty printer functionality, such as indentation. |
| SerializableString | Interface that defines how Jackson package can interact with efficient pre-serialized or lazily-serialized and reused String representations. |
| TreeNode | Marker interface used to denote JSON Tree nodes, as far as
the core package knows them (which is very little): mostly
needed to allow ObjectCodec to have some level
of interoperability. |
| Versioned | Interface that those Jackson components that are explicitly versioned will implement. |
| Class Summary | |
|---|---|
| Base64Variant | Abstract base class used to define specific details of which variant of Base64 encoding/decoding is to be used. |
| Base64Variants | Container for commonly used Base64 variants:
Base64Variants.MIME
Base64Variants.MIME_NO_LINEFEEDS
Base64Variants.PEM
Base64Variants.MODIFIED_FOR_URL
|
| JsonFactory | The main factory class of Jackson package, used to configure and
construct reader (aka parser, JsonParser )
and writer (aka generator, JsonGenerator )
instances. |
| JsonGenerator | Base class that defines public API for writing JSON content. |
| JsonLocation | Object that encapsulates Location information used for reporting parsing (or potentially generation) errors, as well as current location within input streams. |
| JsonParser | Base class that defines public API for reading JSON content. |
| JsonStreamContext | Shared base class for streaming processing contexts used during reading and writing of Json content using Streaming API. |
| ObjectCodec | Abstract class that defines the interface that JsonParser and
JsonGenerator use to serialize and deserialize regular
Java objects (POJOs aka Beans). |
| Version | Object that encapsulates versioning information of a component. |
| Enum Summary | |
|---|---|
| JsonEncoding | Enumeration that defines legal encodings that can be used for JSON content, based on list of allowed encodings from JSON specification. |
| JsonFactory.Feature | Enumeration that defines all on/off features that can only be
changed for JsonFactory . |
| JsonGenerator.Feature | Enumeration that defines all togglable features for generators. |
| JsonParser.Feature | Enumeration that defines all on/off features for parsers. |
| JsonParser.NumberType | Enumeration of possible "native" (optimal) types that can be used for numbers. |
| JsonToken | Enumeration for basic token types used for returning results of parsing JSON content. |
| Exception Summary | |
|---|---|
| JsonGenerationException | Exception type for exceptions during JSON writing, such as trying to output content in wrong context (non-matching end-array or end-object, for example). |
| JsonParseException | Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered. |
| JsonProcessingException | Intermediate base class for all problems encountered when processing (parsing, generating) JSON content that are not pure I/O problems. |
Main public API classes of the core streaming JSON
processor: most importantly JsonFactory
used for constructing
JSON parser (JsonParser
)
and generator
(JsonParser
)
instances.
Public API of the higher-level mapping interfaces ("Mapping API") is found from the "jackson-databind" bundle, except for following base interfaces that are defined here:
TreeNode
is included
within Streaming API to support integration of the Tree Model
(which is based on JsonNode
) with the basic
parsers and generators (iff using mapping-supporting factory: which
is part of Mapping API, not core)
ObjectCodec
is included so that
reference to the object capable of serializing/deserializing
Objects to/from JSON (usually, com.fasterxml.jackson.databind.ObjectMapper
)
can be exposed, without adding direct dependency to implementation.
|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


How to play: Use your arrow keys to move the tiles. When two tiles with the same number touch, they merge into one!
Created by Zhang Zeyu. Based on 2048 by Gabriele Cirulli.


Pirates of the Caribbean: On Stranger Tides
In a new story about the search for truth, betrayal, eternal youth and mortal danger, captain Jack Sparrow will face a woman from his past Angelica. Until the very end, it will not be clear whether their true love binds, or Angelica skillfully pretends to get together with Jack to the mysterious source of eternal youth. She forces captain Jack Sparrow to Board the ship Queen Anne's Revenge, which is controlled by the insidious villain Blackbeard. Our hero finds himself in a situation where he does not know what to fear more – a terrible villain or his old girlfriend.


contaminante¶
kohn - tah - mee - nahn - teh
A package to help find the contaminant transiting source in NASA's Kepler, K2 or TESS data. When hunting for transiting planets, sometimes signals come from neighboring contaminants. This package helps users identify where the transiting signal comes from in their data.
What does contaminante
do?¶
contaminante
uses pixel level modeling of the TargetPixelFile data from NASA's astrophysics missions that are processed with the Kepler pipeline. The output of contaminante
is a Python dictionary containing the source location and transit depth, and a contaminant location and depth. Optionally you can output a figure showing
- Where the main target is centered in all available TPFs.
- What the phase curve looks like for the main target
- Where the transiting source is centered in all available TPFs, if a transiting source is located outside the main target
- The transiting source phase curve, if a transiting source is located outside the main target
An example output is shown below for a target with a transiting contaminant.
Where as a transit that is centered on the target gives the following output:
How do I use contaminante
?¶
You can check out our tutorial for how to run contaminante
. To run contaminante
you will need a target name, a transit period, a transit center and a transit duration.
How do I install contaminante
?¶
You can install contaminante
using pip:
pip install contaminante --upgrade
You can also install contaminante
by cloning this repo:
git clone https://github.com/christinahedges/contaminante
cd contaminante
python setup.py install
Help, I can't install contaminante
!¶
You might not be able to install contaminante
because your computer doesn't support some of the features, or perhaps you're new to Python. Don't worry, you can still use contaminante
! If you're struggling to install, try running contaminante
online using Google's Colaboratory. You can click here to open a new Colaboratory notebook and run contaminante
in the cloud!
Dependencies¶
contaminante
uses the most up to date version of lightkurve
, and uses some of the features available in v2.0. Make sure your lightkurve
installation is up to date before using contaminante.


{% extends 'index.html' %} {% block content %}
(Disclaimer: The following are NOT endorsed by this site, the DoD, or the U. S. Navy. This is a small list to get started in deciding where you should attend college)
This website is geared towards US NAVY members getting started on their journey towards a college degree. The following are ways to contact the owner of this site. If you have changes, spot broken links, or just want to say thank you, follow the links. Feedback is always welcome.
{% for i in contact %}


13.8 Interface for the Solution of
Equations
int root(double (*f)(double x), double (*g)(double x), double *x, int *n,
double delta)
Return Value
0if a root is found, -1 otherwise.
Description
Computes the root of f to
which Newton's method converges given an initial iteration
point. This point is specified in x[0]. The
derivative of f is specified in
g. The argument n is the
maximum number of iterations to perform. The argument
delta is the difference between successive
approximations at which to stop iterating. Upon return,
successive values of x calculated during the
iteration process are returned in the x array.
Upon return, n contains the number of values
in array x. It is the responsibility of the
caller to manage the storage associated with
x.
Complexity
O (n), where n is the maximum number of iterations
the caller wishes to perform. |


Protocols
The following protocols are available globally.
-
An Executor accepts units of work with add(), which should be threadsafe.
See moreDeclaration
Swift
public protocol Executor : AnyObject
-
Protocol for mark of movable types.
Declaration
Swift
public protocol Moveonly
-
Logger protocol.
Messages can contain placeholders. Placeholders form: {name}, where
See morename
is the name of the key in the context dictionary.Declaration
Swift
public protocol Logger
-
Describes a logger-aware instance.
See moreDeclaration
Swift
public protocol LoggerAware
-
Undocumented
See moreDeclaration
Swift
public protocol AtomicArithmeticContract
-
Undocumented
See moreDeclaration
Swift
public protocol AtomicBitwiseContract
-
Declaration
Swift
public protocol AtomicContract


QtConcurrent
Trial to use Doxygen to generate UML class diagram of QtConcurrent module.
concurrent
concurrent Directory Reference
Directories
directory
doc
Files
file
qtconcurrent_global.h
[code]
file
qtconcurrentcompilertest.h
[code]
file
qtconcurrentexception.h
[code]
file
qtconcurrentfilter.cpp
file
qtconcurrentfilter.h
[code]
file
qtconcurrentfilterkernel.h
[code]
file
qtconcurrentfunctionwrappers.h
[code]
file
qtconcurrentiteratekernel.cpp
file
qtconcurrentiteratekernel.h
[code]
file
qtconcurrentmap.cpp
file
qtconcurrentmap.h
[code]
file
qtconcurrentmapkernel.h
[code]
file
qtconcurrentmedian.h
[code]
file
qtconcurrentreducekernel.h
[code]
file
qtconcurrentrun.cpp
file
qtconcurrentrun.h
[code]
file
qtconcurrentrunbase.h
[code]
file
qtconcurrentstoredfunctioncall.h
[code]
file
qtconcurrentthreadengine.cpp
file
qtconcurrentthreadengine.h
[code]
Generated by
1.8.13


docker update
Update configuration of Docker containers.
This command is not supported for Windows containers.
More information: home page
- Update restart policy to apply when a specific container exits:
docker update --restart=always|no|on-failure|unless-stopped container_name
- Update the policy to restart up to three times a specific container when it exits with non-zero exit status:
docker update --restart=on-failure:3 container_name
- Update the number of CPUs available to a specific container:
docker update --cpus count container_name
- Update the memory limit in [M]egabytes for a specific container:
docker update --memory limitM container_name
- Update the maximum number of process IDs allowed inside a specific container (use `-1` for unlimited):
docker update --pids-limit count container_name
- Update the amount of memory in [M]egabytes a specific container can swap to disk (use `-1` for unlimited):
docker update --memory-swap limitM container_name


Getting Started
Getting Started
We always start by creating a RootLayout
.
import { RootLayout } from 'ug-layout';
const root = RootLayout.create({
container: document.body // This can be any HTMLElement
});
Not that we have a root layout all we need to do is configure the renderable tree. For configuring renderables refer to the configuration section of the docs.
import { RootLayout, Layout, Row, View } from 'ug-layout';
const root = RootLayout.create({
container: document.body
});
root.load(
RootLayout.configure({
child: Layout.configure({
child: Row
})
})
)
The above will create a layout with a single row. We haven't configured any renderables
to occupy that row yet. This is where Views
come into play. Views are Renderables
that render a component that we create. We can use factories, classes, or already existing instances.
Read the configuration for the {@link View} Renderable for more information.
Let's create a basic component we want to render.
export class MyComponent {
// This hook gets fired when the component is initialized.
ugOnInit(container: ViewContainer): void {
container.mountHTML('
Hello World!
');
}
}
The ViewContainer
is an object that contains the component instance. It's the link
between your component and the layout framework. This seperation allows for the framework to be
transparent to the component. You only need to expose hooks on your component.
So no that our component is created lets hook it up.
import { RootLayout, Layout, Row, View } from 'ug-layout';
import { MyComponent } from './MyComponent';
const root = RootLayout.create({
container: document.body
});
root.load(
RootLayout.configure({
child: Layout.configure({
child: Row.configure({
children: [{
use: View.configure({
useClass: MyComponent
})
}, {
use: View.configure({
useClass: MyComponent
})
}]
})
})
})
)
So, from this example we have a layout with a row that will render two instances of MyComponet
. This all the configuration needed. This may seem a little verbose at first but this allows for any number of combinations of Renderables
. Since this framework is completely extensible we can create adapters into any frameworks rendering and component engine. For example ug-layout-angular
will render Angular 2 and Angular 1 components.
Views
Views
Views are Renderables that know how to render a specific component. This is where we can integrate it into different frameworks. Let's use the following as our base example. I would read the Getting Started guide before diving in here.
Component
import { ViewComponent } from 'ug-layout';
@ViewComponent()
export class MyComponent {
ugOnInit(container: ViewContainer): void {
container.mountHTML('
Hello World!
');
}
}
Layout
import { RootLayout, Layout, Row, View } from 'ug-layout';
import { MyComponent } from './MyComponent';
const root = RootLayout.create({
container: document.body
});
root.load(
RootLayout.configure({
child: Layout.configure({
child: Row.configure({
children: [{
use: View.configure({
useClass: MyComponent
})
}]
})
})
})
)
View Container
The view container is a special object that manages how the component integrates with the view. It invokes hooks on the component, contains notification observables, and APIs for interacting with the layout framework. In the above example we are setting the content of the view with our components template. The view container also manages when the component is 'ready' allowing for components to resolve asynchronously.
Async View Resolution
Views can have two async resolution phases. We can use a factory that returns a promise or we can use the ugOnResolve
hook and return a promise.
Factory
View.configure({
useFactory: async () => {
const data = await service.fetchData();
return myViewFactory(data); // Returns our component instance.
}
});
ugOnResolve Hook
@ViewComponent()
class MyComponent {
async ugOnResolve(): Promise<void> {
this.data = await this.getData();
}
ugOnInit(container: ViewContainer): void {
// This won't be invoked until the data is fetched.
container.mountHTML('
Hello World!
');
}
}
View.configure({
useClass: MyComponent
});
Component Lifecycle Hooks
These are hooks that get invoked during different points in the lifecycle of the view.
- ugOnResolve(container: ViewContainer) -> Invoked when the component is created, but before the
ugOnInit
hook. Can resolve async operations. - ugOnInit(container: ViewContainer) -> Invoked when the component is ready and resolved.
- ugOnAttach(container: ViewContainer) -> Invoked when the ViewContainer is attached to it's View Renderable.
- ugOnDetach() -> Invoked when the ViewContainer is detached from it's View Renderable. This is useful for component caching.
- ugOnResize(dimensions: { width: number, height: number }) -> Invoked when the dimensions of the container change.
- ugOnVisibilityChange(isVisible: boolean) -> Invoked whenever this view becomes visible or hidden.
- ugOnBeforeDestroy(event: BeforeDestroyEvent) -> Invoked whenever the view is about to be destroyed. The event for this hook is cancellable or can wait on an async operation. This is useful for confirming before closing or halting the closing all together. Note, this is only fired during some destroy events (ex: Tab closing), not every time the view is destroyed.
View Component
The ViewComponent
decorator is a special decorator used to define metadata for the view component. Many of the options for a view can be configured when configuring the view renderable as well.
@ViewComponent({
lazy: true,
cacheable: true
})
export class MyComponent {}
// These can be overriden upon each use of the component.
View.configure({
useClass: MyComponent,
lazy: false,
cacheable: false
});
View Configuration
A view config has the following properties:
lazy: boolean
-> The view container won't be initialized until the view is visible for the first time. This also won't create the component until it is first shown or intialize is explicitly invoked on the ViewContainer.cacheable: boolean
-> Whether the view container and it's component should NOT be destroyed when the View renderable is destroyed. This means you can use the same component instance across different layout configurations.resolution: ResolverStrategy
-> How the view should be resolved with the ViewManager. See the section onResolver Strategies
.token: any
-> The token to use to store this view with the {@link ViewManager}. If usinguseClass
the constructor will be used as the token. If using a factory atoken
must be provided. This token is used to resolve configuration for the component as well.useFactory: Function
-> Use a factory to generate the component.deps: any[]
-> Depenedencies to inject into the factory function. Only applies when usinguseFactory
option.useClass: Type<any>
-> A class that will be instantiated as the component.useValue: any
-> An already create component instance.ref: string
-> A reference identifier. This is used to identify specific component references programmatically.
Resolver Strategies
We can determine how a view gets resolved when it is created or asked for.
ResolverStrategy.TRANSIENT
-> Each time a view is requested to create a component, it will always create a new one.ResolverStrategy.SINGLETON
-> Each time a view is requested to create a component, it will either return an existing instance of that component or create one that will be the single instance for that component.ResolverStrategy.REF
-> Each time a view is requested to create a component, it will either return an existing instance of that component that matches the same ref identifier given or create one that will be registered under the given ref. Note,ref
must be provided or else an error will be thrown.
Custom View Renderables
A {@link View} can be extended like any {@link Renderable} and can be integrated into any framework. Checkout the ug-layout-angular
package for a View that renders Angular 1 and 2 components.
Serialization
Serialization
ugLayout supports serializing a layout's state as JSON that can be stored and read back into a layout. Usually each Renderable has a Serializer associated with it. Let's dive in to serialization basic usage.
Usage
We need to create a SerializerContainer from our root layout. We can use the RootSerializer class which is a SerializerContainer bootstrapped with all the built in Renderables registered.
const rootLayout = RootLayout.create({ container: document.body });
class MyComponent {}
rootLayout.load(
RootLayout.configure({
child: Layout.configure({
child: View.configure({ useClass: MyComponent })
})
})
);
Let's assume we have the root layout instance above. Now we can create out serializer.
import { RootSerializer } from 'ug-layout';
const serializer = RootSerializer.fromRoot(rootLayout);
const layoutJSON = serializer.serialize(rootLayout);
Not we can store this JSON into LocalStorage or any other storage. Now we'll load the root layout from the JSON.
rootLayout.load(serializer.deserialize(layoutJSON));
The deserialize
method returns a ConfiguredRenderable
which is the same as calling RootLayout.configure()
.
Creating Serializers
Each Renderable is not essential a 1 to 1 relation ship but in a lot of cases it is. For example the Layout
Renderable has a LayoutSerializer
which knows how to serialize and deserialize a Layout Renderable. A Stack
has a single StackSerializer
, but it also serializes and deserializes StackHeader
, StackTab
, and StackItemContainer
since they are only applicable to Stacks.
A serializer need to implement the Serializer
interface. Here is an example serializer.
import {
Serializer,
Serialized,
ConfiguredRenderable,
SerializerContainer
} from 'ug-layout';
import { MyRenderable } from './MyRenderable';
export interface SerializedMyRenderable extends Serialized {
someMessage: string;
}
export class MySerializer implements Serializer<MyRenderable, SerializeMyRenderable> {
serialize(renderable: MyRenderable): SerializedMyRenderable {
return {
name: 'MyRenderable',
someMessage: renderable.someMessage
};
}
deserialize(serialized: SerializedMyRenderable): ConfiguredRenderable<MyRenderable> {
return new ConfiguiredRenderable(MyRenderable, {
someMessage: serialized.someMessage
});
}
static register(container: SerializerContainer): void {
container.registerClass('MyRenderable', MyRenderable);
}
}
Builtin Renderables
Builtin Renderables
Here is a list of builtin renderables.
Row
A row renders a list of Renderables horizontally.
Column
A column renders a list of Renderables vertically.
Stack
A stack renders a list of Renderables as a tabbable interface. If the tab is configured with headers the tabs can be dropped onto other stacks.
Layout
A layout is a grouping that contains Renderables underneath it. Visually it does nothing, but it contains it's own DragHost
which restricts items from being dragged outside it's bounds. If you want keep a Stack item from being dragged out side a set of Renderables then you would use a Layout to contain it.
RootLayout
This is the root layout that is created and bootstraps all dependencies for child renderables.
View
Renders components and interfaces with a ViewContainer.
Configuring Renderables
Configuring Renderables
ugLayout uses the ConfiguredRenderable
class as a way to associate configuration between a Renderable and it's configuration. Most built in renderables contain static method named configure
. This method returns a ConfiguredRenderable
instance that contains the provided config and Renderable class.
Layout.configure({
child: Row
});
// Is equal to
new ConfiguredRenderable(Layout, {
child: Row
})
Anywhere something requires a RenderableArg
You can provide a Renderable, a ConfiguredRenderable
or an instance of a Renderable.
Resolving Renderables and Configuration
If you are creating Renderables from a RenderableArg
you can use the resolve
and resolveConfiguration
static methods on the ConfiguredRenderable
class to resolve them.
const layoutConfig = Layout.configure({ child: Row });
const layoutInstance = new Layout();
ConfiguredRenderable.resolve(layoutConfig); // => Layout
ConfiguredRenderable.resolve(Layout); // => Layout
ConfiguredRenderable.resolve(layoutInstance); // => Layout
ConfiguredRenderable.resolveConfiguration(layoutConfig); // => { child: Row }
References
References
Class Summary
| Static Public Class Summary | ||
| public |
Event fired before an item is destroyed. |
|
| public |
An event that can be dispatched from the event bus. |
|
| public |
An class that is thrown when a Cancellable is cancelled. |
|
| public |
An event that can be cancelled. |
|
| public |
|
|
| public |
A control that triggers a tab to close. |
|
| public |
|
|
| public |
|
|
| public |
A container that holds a Renderable class and a configuration to use when it is instanatiated. |
|
| public |
Invokes a custom view hook on any views that receive this event. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
Custom eventing bus that abstracts common patterns between events. |
|
| public |
An instance of a forward ref function. |
|
| public |
A serializer that can be used for renderables that don't container any special logic or configuration. |
|
| public |
A dependency injector for resolving dependencies. |
|
| public |
|
|
| public |
Serializes/deserializes a layout renderable. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public abstract |
The base renderable that all other renderables extend from. |
|
| public |
A class that defines an area in pixels. |
|
| public |
An injector created for renderables. |
|
| public |
Renders the layout. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
A container for running and determining serializers. |
|
| public |
|
|
| public |
A Renderable that renders the Renderable items in a tabbable format. |
|
| public |
Base stack control that all stack controls extend. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
A renderable that is a direct child of a stack. |
|
| public |
|
|
| public |
Renderable representing a stack tab. |
|
| public |
|
|
| public |
Fired when a tab is closed. |
|
| public |
|
|
| public |
Fired when a tab is dragged. |
|
| public |
Event fired when a tab is selected. |
|
| public |
|
|
| public |
A token used for dependency injection. |
|
| public |
|
|
| public |
A renderable that renders a component. |
|
| public |
A container that holds a 1 to 1 relationship with a component instance. |
|
| public |
Responsible for creating view containers from view configurations. |
|
| public |
Executes view hooks on a component instance. |
|
| public |
This service wires up a class instance with custom behavior for dealing with communication between multiple views. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
Interface Summary
| Static Public Interface Summary | ||
| public |
|
|
| public |
An event interface that is emitted from a Draggable. |
|
| public |
An interface that signifies the renderable can handle drops. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
Function Summary
| Static Public Function Summary | ||
| public |
Inject(token: *): ParameterDecorator Marks a param to be injected with the registered provider registered with the token. |
|
| public |
Injectable(config: InjectableConfigArgs): ClassDecorator Marks a dependency as injectable. |
|
| public |
Lazy(): ParameterDecorator Marks a dependency as lazy. |
|
| public |
MemoizeFrom(properties: ...string[]): MethodDecorator A decorator that memoizes a functions computation based on the current and previous value of other parameters. |
|
| public |
ObserveViewHook(hook: string): PropertyDecorator Creates an Observable that emits when the provided hook is invoked. |
|
| public |
Optional(): ParameterDecorator Marks a dependency as optional. |
|
| public |
Self(): ParameterDecorator Will only check the injector creating the dependency. |
|
| public |
ViewComponent(config: ViewComponentConfigArgs): ClassDecorator Registers view metadata with a component class. |
|
| public |
ViewInsert(config: ViewInsertConfigArgs): PropertyDecorator Sets up a view insert method. |
|
| public |
ViewLinkInit(injections: ...any[]): MethodDecorator Sets up an init method that is invoked at the time a view is linked by the ViewLinker. |
|
| public |
ViewQuery(config: ViewQueryConfigArgs): MethodDecorator Sets up a view query with the decorated method as the callback to receive the query results. |
|
| public |
ViewResolve(config: ViewResolveConfigArgs): PropertyDecorator Sets up a view resolve method. |
|
| public |
clamp(val: *, min: *, max: *): * |
|
| public |
defaults(dest: *, src: *): * |
|
| public |
eq(value: *): * |
|
| public |
forwardRef(fn: Function): ForwardRef A factory that creates a ForwardRef. |
|
| public |
get(obj: *, path: *, defaultValue: *, comparer: *): * |
|
| public |
getDefaultMetadata(): {"queries": *, "inits": *, "inserts": *, "resolves": *} |
|
| public |
isBoolean(val: *): * |
|
| public |
isFunction(val: *): * |
|
| public |
isNumber(val: *): * |
|
| public |
isObject(val: *): * |
|
| public |
isObserver(val: *): * |
|
| public |
isPromise(value: *): * |
|
| public |
isString(val: *): * |
|
| public |
isUndefined(val: *): * |
|
| public |
negate(fn: *): * |
|
| public |
|
|
| public |
propEq(prop: *, value: *): * |
|
| public |
|
Variable Summary
| Static Public Variable Summary | ||
| public |
Injection token for injecting the renderables configuration. |
|
| public |
Injection token for injecting the container renderable. |
|
| public |
ContextType: {"NONE": string, "LOAD": string} |
|
| public |
|
|
| public |
Injection token for the Document API. |
|
| public |
Injection token for injecting an HTML element associated with the renderable. |
|
| public |
|
|
| public |
Key used to assign the injector to on Renderables. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
Layout: * A layout is a set of renderables scoped to a drag host. |
|
| public |
LinkerMetatdataRef: docs/di.js~Token |
|
| public |
|
|
| public |
Injection token for injecting the patch method generated by snabbdom. |
|
| public |
Injection token for the root configuration used to create a RootLayout |
|
| public |
|
|
| public |
Symbol that signifies that an XYItemContainer's ratio is unallocated. |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
ViewComponentRef: docs/di.js~Token |
|
| public |
uid: * |
Typedef Summary
| Static Public Typedef Summary | ||
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
ProviderArg: Provider | Type<*> |
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
External Summary
| Static Public External Summary | ||
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|
|
| public |
|


Home
About
Catering
Events
Truck of the Month
Why Us
TRUCK OF THE MONTH
Here at Chowster we like to highlight one special food truck a month and this months winner is!
BOB'S BURGERS FOOD TRUCK!!
Copyright CHOWSTER @2020


Hello! My name is Jonathan, but you already knew that. I'm a 2nd year Computer Science & Engineering major at UCLA.
In my time at UCLA, I've had the opportunity to explore the great realm of computers, code, and engineering through the wonderful coursework provided by the CS department in addition to technical experience I've gained outside of class through various projects and organizations. Check out some of the projects I've worked on
here and organizations I've worked with below!
I also find opportunities during what free time I have doing
graphic design and developing my skill as a musician. I hope to continue improving
as a pianist for the rest of my life.
Amazon
I'll be working as a Software Development Engineering Intern on the
Amazon Go team during the summer of 2018!
BuildUCLA
Software Developer | June 2017 - Current
Current Project: Image Collection Navigation (
GitHub)
Over the years, UCLA Library has collected hundreds of images related to UCLA, and our job is to build a website to creatively visualize these images, with the help of machine learning similarity and clustering algorithms. I'm building the website with
Flask and Neo4j, a graph database.
Previous project:
Community Cataloging (
GitHub), a project whose goal is to streamline the process of cataloging books written in foreign languages that have been off the library shelves for too long.
The app, hosted with Amazon Web Services, consists of ScribeAPI, a Ruby on Rails app which makes up the main interface, Tesseract OCR, which we're using to automate the conversion of book titles and other phrases from images to text, and a Django image uploader
I worked towards connecting separate components by sending image and marking data to ScribeAPI. This task involved investigating how each API works, analyzing how we can push and pull data conveniently, and actually connecting them using
Python scripts.
Poasis
Web Developer | April 2017 - June 2017
I worked for a local startup based in Westwood, CA focused on connecting owners of open parking spots to those willing to purchase parking spots, analogous to Uber but for parking. The other student developers and I were in charge of maintaining and adding on to the company
website.
While I was there, I worked on a new webpage that was needed for apartment owners with parking spots to efficiently post their spots all at once. This involved writing PHP code to handle client-side logic and SQL to push and pull information from our database.
Circle K International
Technology Chair | April 2018 - Present |
California-Nevada-Hawaii District
Audio/Visual & Technology Chair | May 2017 - November 2017 |
CNH District Fall Training Conference Committee
Graphic Design Chair | March 2017 - March 2018 |
UCLA Chapter
Circle K International is the largest collegiate service organization in the world, and our UCLA Chapter is one of the strongest in the world. Community service has provided me an outlet for giving back to others rather than just building myself and has definitely become a large part of my college experience.
I currently serve as the Technology Chair for the CNH District of Circle K, making me responsible for overseeing all things technology in the District. I maintain and update the District website,
cnhcirclek.org, and work with a board of Lieutenant Governors and fellow Committee Chairs to ensure all the District's technical needs are satisfied. I am also starting a CNH District Technology Committee, the first of its kind, to create a team of individuals who will bring technology to even greater use in our organization.
Fall Training Conference (FTC) is an annual 700 attendee event in Sonora, CA focused on educating and connecting members from California, Nevada, and Hawaii. As Audio Visual & Technology Chair for the FTC Committee, I built the
website and handled all AV equipment during the event.
As Graphic Design Chair, I was in charge of everything design-related, including flyers, social media graphic announcements, and Facebook banners. I chaired a committee and delegated design work to five committee members, acting as the lead designer and manager of the graphic design committee. Check out some of my designs on the
Graphics tab.
Daily Bruin
Graphics Contributor | January 2017 - June 2017
The Daily Bruin is the award-winning campus newspaper at UCLA.
As part of the graphics department, I picked up new graphic design skills, created designs to be printed on the paper, and worked alongside teammates on creative standalone graphics highlighting useful, interesting topics for the student body.


| DOSE: |
1800 mg |
oral |
Caffeine |
(pill / tablet) |
I never really considered caffeine a drug prior to this experience. I was aware of its addictive capabilities, but when I begin to lose control of my body and have a detached mindset, well, then I are in trouble.
Let me start from the beginning. My friend took caffeine pills regularly simply because he liked the speedy effects. Because of this, I decided to try them myself. Taking one or two at first, I soon found he was right. They were okay. I often felt alert, stayed up later if needed, and could start my day better with couple pills rather than brewing coffee. No big deal.
I was curious how high my dosage could go. Feeling competitive, as my friendís record was six, I decided to take eight. The experience started out fairly normal, with moderate shakes in my fingers and feeling very uppity and Ďon the ballí.
I had eaten a fairly large meal before this experience, maybe ninety minutes prior, but I got the urge to puke regardless. Being very experienced with alcohol, I knew the worst thing I could possibly do is try to hold it back, so I vomited up my entire dinner.
This, suffice to say, shocked me. Looking into the toilet bowl - tingly and amazed - I saw everything I ate, but no pills.  I flushed the toilet, then got a severe urge to go to the bathroom. Then everything began to get frightening.
Sitting on the toilet bowl, I first became extremely hot. I felt feverish, and, for fear of crapping on the floor, took off my clothes while still on the toilet. I grabbed a nearby book and started reading it. The shaking got worse, and it became actually difficult to hold the book. I found myself reading the same lines over and over again.
I lost my sense of time and my feet fell asleep. This was normal, but I tried to wiggle my toes and realized I couldnít. I became nervous. I started to get a pounding headache, and all this time the need to puke or go to the bathroom did not go away.
I dropped the book and clutched my stomach as the shakes took over. I decided to give up going to the bathroom and put my clothes back on, but I found I couldnít stand up.
My heart began to beat faster and faster. I feared I would have a heart attack. The world appeared to be grainy and pixelated. I felt extremely hot, and I opened the bathroom door to get the air moving; I didnít care if anyone would see me.
I threw myself on the floor and waited for my blood to circulate. Eventually it did. I pulled on my underwear and pulled myself up to a standing position using the sink. I felt shaky and woozy at the same time, and it was all I could do to walk to my bed. I was unable to walk in a straight line like a drunk and I was incredibly dizzy. I fell on my bed.
I looked at my clock and realized that the entire experience took about six hours, from taking the pills to laying down on the bed. About five and a-half of those hours were spent sitting on the toilet in pain. I passed out.
I slept for about two hours, then got up and went to school as usual. Though the tingling was gone, I had shakes and mild nausea for most of the next day - something of a caffeine hangover.
Losing control of my body was not cool, but I still take caffeine in liquid form. I took tons of caffeine before this experience, and I had no idea I could lose control of my body like that. I have not taken pill-form caffeine since the incident.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Pyramid Solitaire Solver
Web Service Guide
The source code for this service is available on GitHub.
This service is designed to solve
Pyramid Solitaire
games according to the rules in Microsoft Solitaire Collection:
-
The game uses a standard 52-card deck, and only uses the numeric value
of the cards. Aces are always 1 and Kings are 13.
-
28 cards are in a seven row pyramid formation with one card on top
and seven cards on the bottom row. Each card has two cards covering
it from below (excluding the bottom row). The remaining 24 cards
are face up in a single stack called the stock pile. There's also a
waste pile that starts out empty.
-
The goal of the game is to remove all 28 pyramid cards, even if there
are still cards remaining in the stock or waste piles.
-
Actions the player can perform using the uncovered pyramid cards and
the top cards of the stock and waste piles:
- Remove a pair of cards that add up to 13.
- Remove a King by itself since it counts as 13.
- If the stock pile isn't empty, draw a card from the stock pile to the waste pile.
- If the stock pile is empty, recycle the waste pile back into the stock pile. This can only be done twice per game.
The Pyramid Solitaire Solver can solve the following types of challenges:
-
Board Challenges: clear the 28 pyramid cards. There can still be cards
in the stock pile and waste pile.
-
Score Challenges: reach the goal score. For example, "Earn a score
of 2,300." The maximum score in a single game is 1290 so completing
this challenge requires playing multiple games.
-
Card Challenges: remove cards of a given rank. For example, "Clear
8 Queens in 2 deals." The player can only clear up to four cards in
a single game so this requires multiple games as well. If the player
clears the board, the next deal does not count towards the 2 deal limit
in the example.
Building a Deck
Cards are two characters, consisting of a rank followed by a suit. Note that
a ten is a letter T, and that all ranks are uppercase, and all suits are
lowercase.
- Card ranks: A 2 3 4 5 6 7 8 9 T J Q K
- Card suits: c d h s
Decks are strings containing each card of a standard 52-card deck, without any
whitespace or delimiters. The service will let you know if there are missing
or duplicate cards.
An example deck string:
Ac2c3c4c5c6c7c8c9cTcJcQcKcAd2d3d4d5d6d7d8d9dTdJdQdKdAh2h3h4h5h6h7h8h9hThJhQhKhAs2s3s4s5s6s7s8s9sTsJsQsKs
The above deck string represents a game like this where the 3h is the top of
the stock pile and the Ks is the bottom of the stock pile.
Ac
2c 3c
4c 5c 6c
7c 8c 9c Tc
Jc Qc Kc Ad 2d
3d 4d 5d 6d 7d 8d
9d Td Jd Qd Kd Ah 2h
3h 4h 5h 6h 7h 8h 9h Th Jh Qh Kh As 2s 3s 4s 5s 6s 7s 8s 9s Ts Js Qs Ks
How to use the services
After building a deck and adding the other parameters for Score and Card
challenges shown below:
-
GET [challenge request URI] can retrieve a solution for the
game if it already solved the game and the solution exists in the
database. The results can be:
-
If the solution exists, the status code 200 (OK) and JSON for
the solution details will be returned.
-
If the solution doesn't exist, the status code 404 (Not Found)
will be returned. At this point you can POST the challenge to
be solved (described next).
-
POST [challenge request URI] will submit a challenge to be
solved. It follows the process described by
REST and long-running jobs.
The results can be:
-
If the solution exists already, the status code 200 (OK) and JSON
for the solution will be returned.
-
If the solution doesn't exist, the status code 202 (Accepted) and
JSON including a link to check on the progress will be returned.
The link will look something like /pyramid-solitaire/solver/tasks/{id}.
-
GET [task URI] is given when POSTing a challenge. The results
can be:
-
If it hasn't finished calculating the solution, the status code
200 (OK) will be returned along with JSON indicating the
solution is still pending.
-
If it has finished calculation the solution, the status code
303 (See Other) will be returned along with a link to see the
solution. Browsers may automatically redirect to the new link
and return the solution.
Board Challenges
The Board Challenge will try to find a way to clear the board in the fewest
steps possible. If it's not possible, then it will have a solution that
basically says to ask for a new deal.
/pyramid-solitaire/solver/board?deck=...
Score Challenges
When the request just contains a deck, without goalScore and currentScore, it
will just try to maximize the score. Otherwise the solver knows the solution
should stop when it reaches the goal.
/pyramid-solitaire/solver/score?deck=...
/pyramid-solitaire/solver/score?goalScore=1290¤tScore=0&deck=...
Card Challenges
The solver will try to find the minimum steps necessary to remove enough cards
to reach the goal. This may return two solutions. For example, if the goal is
to remove 4 Jacks, and there's a way to remove 2 while clearing the board and
3 while not clearing the board (requiring using one of a limited number of
re-deals), it can't decide which solution is best so it returns both.
/pyramid-solitaire/solver/card?rankToRemove=J&goalNumberToRemove=4¤tNumberRemoved=0&deck=...


User’s need to flip between multiple focused panes/views of content.
Description
Tabs manage stacked panes of content, giving the users the ability to view only the content pane they are interested in. Each tab button has a corresponding content pane. Tabs build on a real world metaphor. The selected state is reinforced with the tab metaphor of a folder physically in front of the others in the set.
Basic functionality
You have multiple categories/views/panes of content, but there is the need to only show one pane at a time.
Tabs are listed in a horizontal row.
Avoid overflowing tabs to new lines.
Tab titles should be short and predictable.
Tab buttons can contain icons, text, both, and even dropdowns.
Normal tabs
Use the normal tabs as primary tabs for a page or an important section. Each instance of normal tabs can have one or several Light Tabs to further order content. When used in that manner, they are then called Nested tabs.


I have had visual and auditory hallucinations all my life, from childhood. I was never afraid to try any hallucinogenic drug due to my normal state. I routinely hallucinate without the use of drugs. I do not suffer HPPD, it started before I ever tried drugs.
When I tried Salvia Divinorum I was sober. I had not used any drugs for more than 2 weeks prior to my first experience. I tried 10X in a bong packed with ice. I packed the bowl and smoked it, taking care to hold my breath for a full 20 seconds each time I filled my lungs. I smoked 5 bowls total the first time.
The first major effect was a 'head rush' or the feeling of 'light headedness'. The rush lasted a few minutes after each bowl. After the rush I felt sober. I walked around the room and noticed that I was NOT hallucinating for the first time in many hears. After the fifth bowl I gave up on the Salvia. I then used Nitrous, but the result was boring with little effect.
The next day and for 16 days I noticed that I was not hallucinating. 17 days after my first use of Salvia I began to have minor hallucinations. One month after my first use my hallucinations were back, but quite mild.
I do not perceive alternate realities but I feel calm and entirely 'real'.
I have tried Salvia a second time, last night, and had the same result. I had a craving to get 'high' last night. I smoked the Salvia and now have no desire for intoxicants. It was not an unpleasant experience at all.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Chapter 9 Husbandry_stickleback_food
9.1 Stickleback Feeding
(created May 6, 2008 by m currey, revised October 21, 2014 by mcc)
9.1.1 Materials:
- Fish food mix or dry fry food
- Decapsulated Artemia (see artemia decapsulating SOP)
- Color coded feeding Spoon
9.1.2 Fish foods for fry and juvenile/adults:
- Fry - newly hatched baby brine shrimp (see hatching brine shrimp SOP) and Zeigler Larval Diet (Larva “Z” Plus 250-450 Microns).
- Juvenile and Adult fish food mix (see fish food mix SOP).
Dry Foods Are Stored in freezer in the stickleback facility
Procedure: - Fry are located along the south wall of the summer room. - AM feeding: Feed fry once per day with newly hatched brine shrimp (this should happen during the opposite feeding of larval diet) - PM feeding: Feed fry once per day with Ziegler larval diet 1/8 spoon full. - Juvenile and Adults are located in the 20 gallon tanks in the Summer and Winter rooms. Additionally, individualized adults are sometimes located on the fry rack in the Summer room. Please check white board for notification of adults on fry rack. - Feed juveniles and adults twice per day with dry food mix. Using the color coding on spoon, food mix, and tags on tanks. (e.g. for adults: use the red spoon, red food mix, and feed the tanks with a red tag). - Unused brine shrimp can be fed to juvenile and adult fish.
9.1.3 Food Storage and Handling:
- See Fish food storage SOP.
Initial daily check list after you have fed.
9.2 Fish Food Mix
(created August 25, 2011 m currey)
9.2.1 Materials:
- Freezer
- Fridge
- 1 gallon bucket with a tight seal
- plastic measuring cup
9.2.2 Dry Mix:
- Mix the following dry foods in 1 gallon bucket
9.2.3 Juvenile Mix:
- 4 cups Pentair finfish starter ZC1
- 1 cup New Life Spectrum optimum saltwater flake
- 1 cup Ziegler AP100
9.2.4 Adult mix:
- 4 cups Pentair finfish starter ZP1
- 4 cups Pentair finfish starter ZC1
- 1 cup New Life Spectrum grow
- 1 cup New Life Spectrum optimum saltwater flake
- 1 cup Hikari micro pellet
- 1 cup Hikari marine S
- 1/8 cup golden pearls
9.2.5 Storage:
- Label with expiration date (6 months after making) and store at -20°C.
9.3 Fish Food: Storage and Sources
(created by M Currey, August 25, 2011)
Label all foods with received date and expiration date (see below for how to determine expiration date).
9.3.1 Brine Shrimp:
Good indefinitely if frozen in tightly sealed container
1 Upon receiving label with received date. Store unopened tins in -20°C freezer. After de-capsulation label with date de-capsulated and date of expiration (30 days from de-capsulation). Store de-capsulated shrimp at 4°C.
Source – Brine Shrimp Direct, www.brineshrimpdirect.com
9.3.2 Golden Pearl Larval Diet:
- 800 – 1000 micron
Good 3-5 years if kept in freezer
- Store in -20°C freezer.
- Unopened label with expiration date 3 years from receiving date.
- Upon opening change expiration date to 6 months from date opened.
Source – Brine Shrimp Direct, www.brineshrimpdirect.com
9.3.3 Hikari dry foods:
• Marine S • Micro Pellets
If un-opened, expiration date is labeled on container by manufacturer. Once opened the food is good for 6 months.
- Keep out of direct sunlight, high heat, and humidity.
- Store at 4°C.
- Upon opening change expiration date to 6 months from date opened.
Source – Pet Mountain, www.petmountain.com That Pet Place: http://www.thatpetplace.com
New Life Spectrum dry foods:
- Optimum saltwater flakes
- Growth Formula
If un-opened, expiration date is labeled on container by manufacturer. Once opened the food is good for 6 months.
• Keep out of direct sunlight, high heat, and humidity. • Store at 4°C. • Upon opening change expiration date to 6 months from date opened.
Source – Jehmco, www.jehmco.com
9.3.4 Zeigler Larval dry food:
- AP100 (150-250 microns)
Good 2 years if kept unopened and in freezer.
• Upon receiving label with received date and expiration date (2 years from received date). • Store at 4°C. • Upon opening change expiration date to 6 months from date opened.
Source – Aquatic Ecosystems, http://pentairaes.com Pentair Finfish Starter dry foods:
- ZP1 - 1.5 mm slow sinking pellet
- ZC1 – 0.6 – 0.85 mm #1 crumble
If un-opened, expiration date is labeled on container by manufacturer. Once opened the food is good for 6 months.
• Keep out of direct sunlight, high heat, and humidity. • Store at 4°C. • Upon opening change expiration date to 6 months from date opened.
Source – Aquatic Ecosystems, http://pentairaes.com
9.3.5 Selcon (brine shrimp supplement):
Good 1 year if kept unopened and in fridge.
- Upon receiving label with received date and expiration date (1 years from received date).
- Store at 4°C.
Source – Aquatic Ecosystems, http://www.aquaticeco.com/
9.3.6 Frozen Mysid and Blood Worms:
Expiration date printed on front label.
- Upon receiving label with received.
- Store at -20°C.
Source – Nautilus Tropical Fish – Springfield Oregon, 727 Main St.<PHONE_NUMBER>
9.4 Hatching and Feeding Brine Shrimp
(created by M Currey 5/6/08, updated 151201 mcc)
9.4.1 Materials Needed:
- De-capsulated Brine Shrimp
- Rock Salt
- 105 μm mesh shrimp collector
- Baking Soda
- Squirt Bottle
9.4.2 Procedure:
- Collect Brine Shrimp: Drain entire cone into 105 μm mesh shrimp collector (located on shelf near cone). Rinse and pour shrimp into squirt bottle. Feed fish. Rinse squirt bottle and place on shelf to dry.
- Reset Brine Cone: Fill cone with DI water to 10 L. Put airline and heater (set at 80°F) into cone. Add 300 ml of rock salt and 1 scoop (5 ml) of baking soda. Obtain de-capsulated brine from refrigerator and shake to homogenize solution. Measure out 150 ml* of de-capsulated brine and add it to the cone.
- Wait 24 hours and repeat….
- The amount of brine shrimp needed will vary depending on the number of juvenile fish that need to be fed. If there is a need for more brine shrimp add more de-capsulated brine to cone and leave a note for the next person. Increase the amount in 50 ml increments. *
9.5 Artemia Decapsualtion
(Adapted by M Currey 4/3/08, 151201 updated by mcc)
9.5.1 Materials:
- 15 oz can of dried Artemia cysts (approximately 430 g)
- 4.3 L ~6% laundry grade bleach
- Rock Salt (NaCl)
- 125 ml 40% Lye (NaOH) solution
- 30.0 g Sodium thiosulfate (Na2S2O3)
- 16 L Hatching Cone with aeration
- 125 μm mesh bag (Aquatic Eco-Systems PMB3, 125 micron x 18")
- Several 3-5 L beakers
- (1-2) Squirt bottles - squeeze type
9.6 Solutions:
Solutions should be prepared in advance *
Bleach, ~6% laundry grade
25 ppt Salt Solution:
- Combine: 50 g Rock Salt (NaCl) To 2.0 L with tap water
- Stir to dissolve completely.
- 40% Lye (NaOH) solution
- Combine: 200 g Lye (NaOH) To 500 mL with tap water
- Stir to dissolve completely.
- Store in refrigerator (4°C)
- Buffered Salt Solution
- Combine: 2L, 25 ppt Salt Solution
- 125 mL 40% Lye Solution, pre-chilled to 4°C
- 1.0% Sodium Thiosulfate
- Combine: 30 g sodium thiosulfate To 3.0 L with tap water
- Stir to dissolve.
- Saturated Brine
- Combine: ~25g Rock Salt to 4.0 L with tap water
- Aerate to dissolve.
9.6.1 Procedure:
- Cyst hydration: Hydrate one full can of dried cyst in 5 L of tap water in a hatching cone with aeration for 1 hour at room temp. Examine the cyst under a dissecting scope with top lighting before proceeding. Dry cysts are dimpled, resembling a deflated basketball, whereas fully hydrated cysts are completely spherical in shape. The cysts must be fully hydrated prior to the de-capsulation step. If cysts are not completely spherical after 1 hour, continue the hydration process (for a maximum of 2 hours), checking the progress of the cysts under a microscope every 15 min.
- Filter and rinse cysts: Collect the hydrated cyst in a 125 um mesh bag and rinse with cool tap water.
- Transfer cysts back to the cone: Add the Buffered Salt Solution to the cone and aerate (save back a filled squirt bottle of salt solution to help transfer cysts to cone). Transfer cysts into cone.
- De-capsulation: Add the bleach (4.3 L) to the cone and continue aeration. Watch the cysts turn from brown to grey to orange, When the cysts are 90% orange, stop the reaction by quickly siphoning the cysts through a 125 um mesh bag and rinsing well with cool tap water.
- Neutralization residual chlorine: To neutralize any residual chlorine transfer the mesh bag to a clean 4 L beaker and pour the 1.0% Sodium Thiosulfate (3L) into the bag. Soak the cysts in the sodium thiosulfate solution for ~1 min, then rinse the cysts with de-ionized tap water. Rinse until discharge turns clear.
- Dehydration for long-term storage: Transfer the cysts back to the cone with 4 L of saturated brine and aerate until salt is dissolved. Transfer dehydrated cyst to (5 or 6) 1 L Nalgene bottles filled with 200 - 300 grams of salt. Add enough salt so that it does not dissolve when de-capsulated brine is added. Fill the bottles with de-capsulated brine. Store in refrigerator. The de-capsulated brine will store for at least 1 month. Hatch brine as you would capsulated brine (see Hatching and Feeding Brine SOP).
9.7 Moina
Materials: • 10 gallon glass tanks • corner sponge filter • Air supply • Rotifer diet • Powdered nannochloropsis
9.7.1 Procedure:
- Fill 10 gallon tank 3/4 full of stickleback system water
- Add corner filter and activate with air.
- Add Moina
- Change water once every 2-3 weeks by removing half of the water and replacing with stickleback water.
- DO NOT break tank down and clean as moina do not respond well to this.
9.7.2 Feeding:
- Add 15 drops of rotifer diet and 1/8 scoop of powdered nannochloropsis each day.
9.8 Mysid Shrimp
For a description of the mysid generator please visit: http://www.mblaquaculture.com/assets/docs/MBL_AQ_Mysid_Generator.pdf
9.8.1 Materials:
• 10 gallon tank generator system • Salt water
9.8.2 Feeding:
- Feed newly hatched brine shrimp daily to both adults and juveniles.
9.8.3 Water Change:
- 2-3 times per week empty 5 gallons of water from the system and replace with new make up water.
- Make new water in 5 gallon bucket by adding DI water and 2 scoops of salt.


DataDistributionManager library. More...
#include "DataDistributionManagerTypes.h"
Go to the source code of this file.
Classes | |
| struct | ClusterHealthElement |
| Contains information needed from the cluster management. More... | |
| class | ITimeMeasureWrapper |
| Interface to manage time information. More... | |
| class | TimeMeasureWrapper |
| Class to allocate an ITimeMeasureWrapper. More... | |
| class | IDataDistributionLog |
| Interface to reports logging. More... | |
| class | IDataDistributionCallback |
| The C++ callback interface to be externally implemented. More... | |
| class | DataDistributionCallback |
| Class to convert C style callback into C++ callback. More... | |
| struct | UnderlyingEventData |
| Class to reports information from transport subsystem. More... | |
| class | IDataDistributionChannel |
| The basic interface for all channel. More... | |
| class | IDataDistributionChannelCallback |
| The C++ callback interface to be externally implemented. More... | |
| class | DataDistributionChannelCallback |
| Class to convert C style dataDistributionUnderlyingEvent callback into IDataDistributionChannelCallback C++ callback. More... | |
| class | IDataDistributionMastershipCallback |
| The C++ callback interface to be externally implemented. More... | |
| class | DataDistributionMastershipCallback |
| Class to convert C style callbacks into IDataDistributionMastershipCallback C++ callback. More... | |
| class | IDataDistributionChannelBase |
| Base interface to be implemented from channel manager. More... | |
| class | IDataDistributionTransport |
| Interface to be implemented from transport subsystem. More... | |
| class | IDataDistributionSubsystem |
| Interface to be implemented from subsystem. More... | |
| class | IDataDistributionMastershipCommon |
| Interface to be implemented from mastership subsystem. More... | |
| class | IDataDistribution |
| Interface to be implemented from common manager. More... | |
| class | DataDistribution |
| Main entry point to activate an instance of IDataDistribution. More... | |
Typedefs | |
| typedef const char *(FUNCALL * | dataDistributionConfigurationCb) (const void *opaque, const char *channelName, const char *key, const char *value) |
| C-style callback invoked for each key-value in the configuration. More... | |
| typedef void(FUNCALL * | dataDistributionLoggingCb) (const void *opaque, const DDM_LOG_LEVEL level, const char *source, const char *function, const char *logStr) |
| C-style callback invoked when a log is emitted from subsystem. More... | |
| typedef void(FUNCALL * | dataDistributionCompletelyDisconnectedCb) (const void *opaque, const char *channelName, const char *reason) |
| C-style callback invoked on a complete disconnection . More... | |
| typedef struct DDM_EXPORT UnderlyingEventData | UnderlyingEventData |
| Class to reports information from transport subsystem. More... | |
| typedef struct DDM_EXPORT UnderlyingEventData * | pUnderlyingEventData |
| typedef void(FUNCALL * | dataDistributionUnderlyingEvent) (const void *opaque, const CHANNEL_HANDLE_PARAMETER, const UnderlyingEventData *uEvent) |
| C-style callback invoked to report UnderlyingEventData. More... | |
| typedef void(FUNCALL * | dataDistributionOnClusterStateChange) (void *opaque, DDM_CLUSTEREVENT change, int64_t serverid) |
| C-style callback invoked to report cluster state change. More... | |
| typedef void(FUNCALL * | dataDistributionOnStateChange) (void *opaque, DDM_INSTANCE_STATE newState, DDM_INSTANCE_STATE oldState) |
| C-style callback invoked to report a state change. More... | |
| typedef void(FUNCALL * | dataDistributionOnStateReady) (void *opaque, void *pState, int64_t len) |
| C-style callback invoked when a state transfer is completed. More... | |
| typedef void(FUNCALL * | dataDistributionOnRequestedState) (void *opaque, void **pState, size_t *len) |
| C-style callback invoked when a state transfer is requested. More... | |
| typedef void(FUNCALL * | dataDistributionOnMultiplePrimary) (void *opaque, int64_t myId, int64_t otherId) |
| C-style callback invoked when multiple primary server are detected. More... | |
| typedef void(FUNCALL * | dataDistributionFirstStateChange) (void *opaque, DDM_INSTANCE_STATE newState) |
| C-style callback invoked to report a first state change. More... | |
| typedef void(FUNCALL * | dataDistributionChangingState) (void *opaque, DDM_INSTANCE_STATE actualState, DDM_INSTANCE_STATE futureState) |
| C-style callback invoked to report a starting instance state change. More... | |
| typedef void(FUNCALL * | dataDistributionChangedState) (void *opaque, DDM_INSTANCE_STATE actualState) |
| C-style callback invoked to report a finished instance state change. More... | |
| typedef std::map< int64_t, ClusterHealthElement * > | ClusterHealth |
| Association map between server id and ClusterHealthElement. More... | |
| typedef std::map< int64_t, ClusterHealthElement * >::const_iterator | ClusterHealthIterator |
| Iterator of ClusterHealth. More... | |
DataDistributionManager library.
DataDistributionManager.h contains the public C++ API for DataDistributionManager. The API is documented in this file as comments prefixing the class, function, type, enum, define, etc. The C++ interface is STD C++ '03 compliant and adheres to the Google C++ Style Guide.
| typedef std::map<int64_t, ClusterHealthElement *> ClusterHealth |
Association map between server id and ClusterHealthElement.
| typedef std::map<int64_t, ClusterHealthElement *>::const_iterator ClusterHealthIterator |
Iterator of ClusterHealth.
| typedef void(FUNCALL * dataDistributionChangedState) (void *opaque, DDM_INSTANCE_STATE actualState) |
C-style callback invoked to report a finished instance state change.
C-style callback invoked when subsystem needs to report a state change.
actualState
reports the actual DDM_INSTANCE_STATE state
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionChangingState) (void *opaque, DDM_INSTANCE_STATE actualState, DDM_INSTANCE_STATE futureState) |
C-style callback invoked to report a starting instance state change.
C-style callback invoked when subsystem needs to report a state change.
futureState
reports the future DDM_INSTANCE_STATE state actualState
reports the actual DDM_INSTANCE_STATE state
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionCompletelyDisconnectedCb) (const void *opaque, const char *channelName, const char *reason) |
C-style callback invoked on a complete disconnection .
C-style callback invoked when subsystem detects a complete disconnection from central server or other peers. channelName
reports the disconnected channel reason
is the reason of disconnection.
The callback's opaque
argument is the opaque set with DataDistributionCallback::create().
| typedef const char*(FUNCALL * dataDistributionConfigurationCb) (const void *opaque, const char *channelName, const char *key, const char *value) |
C-style callback invoked for each key-value in the configuration.
C-style callback usable to override configuration parameters in some special conditions. channelName
reports the channel involved (null for global parameters), key
is the parameter key to be checked and value
is the actual value.
value
if no change is needed, otherwise any new string value according to the expected parameter typeThe callback's opaque
argument is the opaque set with DataDistributionCallback::create().
| typedef void(FUNCALL * dataDistributionFirstStateChange) (void *opaque, DDM_INSTANCE_STATE newState) |
C-style callback invoked to report a first state change.
C-style callback invoked when subsystem needs to to report a first state change
newState
DDM_INSTANCE_STATE state
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionLoggingCb) (const void *opaque, const DDM_LOG_LEVEL level, const char *source, const char *function, const char *logStr) |
C-style callback invoked when a log is emitted from subsystem.
C-style callback usable to receive log information. level
is the DDM_LOG_LEVEL of the log reported source
is the module source name of the log function
is the function, within the module, reporting the log
logStr
is the reported log stringThe callback's opaque
argument is the opaque set with DataDistributionCallback::create().
| typedef void(FUNCALL * dataDistributionOnClusterStateChange) (void *opaque, DDM_CLUSTEREVENT change, int64_t serverid) |
C-style callback invoked to report cluster state change.
C-style callback invoked when subsystem needs to report a cluster state change.
change
reports the DDM_CLUSTEREVENT event serverid
the server id reporting the change
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionOnMultiplePrimary) (void *opaque, int64_t myId, int64_t otherId) |
C-style callback invoked when multiple primary server are detected.
C-style callback invoked when subsystem needs to report there are multiple primary server are detected
myId
my primary identifier otherId
other primary identifier
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionOnRequestedState) (void *opaque, void **pState, size_t *len) |
C-style callback invoked when a state transfer is requested.
C-style callback invoked when subsystem needs to request a state transfer. Fill pState
and len
with state information
pState
pointer to the buffer of the state len
the length of the buffer
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionOnStateChange) (void *opaque, DDM_INSTANCE_STATE newState, DDM_INSTANCE_STATE oldState) |
C-style callback invoked to report a state change.
C-style callback invoked when subsystem needs to report a state change.
newState
reports the new DDM_INSTANCE_STATE state oldState
reports the new DDM_INSTANCE_STATE state
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionOnStateReady) (void *opaque, void *pState, int64_t len) |
C-style callback invoked when a state transfer is completed.
C-style callback invoked when subsystem needs to report a completed state transfer
pState
pointer to the buffer of the state len
the length of the buffer
The callback's opaque
argument is the opaque set with DataDistributionMastershipCallback::create().
| typedef void(FUNCALL * dataDistributionUnderlyingEvent) (const void *opaque, const CHANNEL_HANDLE_PARAMETER, const UnderlyingEventData *uEvent) |
C-style callback invoked to report UnderlyingEventData.
C-style callback invoked when subsystem needs to report an UnderlyingEventData. channelHandle
reports the channel handle source of UnderlyingEventData uEvent
the UnderlyingEventData event
The callback's opaque
argument is the opaque set with DataDistributionChannelCallback::create().
| typedef struct DDM_EXPORT UnderlyingEventData * pUnderlyingEventData |
| typedef struct DDM_EXPORT UnderlyingEventData UnderlyingEventData |
Class to reports information from transport subsystem.
This class allocates an UnderlyingEventData with information from subsystem


--- layout: post title: ScreenRecycler date: 2006-10-29 00:00:00 category: interfaces-&-interaction ---
ScreenRecycler: "Most Mac users have a spare computer sitting right next to their main computer on their desk. ScreenRecycler now enables you to use this spare computer as second display for your Mac. You can even use an idle machine for that purpose."


iPOJO Nature is an Eclipse plug-in from OW2 Chameleon project providing a project nature and a builder for Java and PDE projects. It is based on the iPOJO manipulator, so it is compatible with metadata.xml and Java annotations component descriptions.
It automates the manipulation of class files by iPOJO after their compilation by the Java plug-in. This way, the developer can use an OSGi Run/Debug Configuration without using an external tool nor a Maven plug-in to run or test an iPOJO components.
See the credits
The iPOJO Nature plug-in is distributed under Apache License v2.0.
There are two features in this extension :


A cute live softwareヾ(ｏ･ω･)ﾉ
Moelive to support 32-bit and 64-bit Windows operating system, for your better live, it is recommended to use a computer with more than 8GB of memory.
The linux version may be supported in the future. You can run it on open source hardware and create unlimited possibilities.
In the air, in the water, the filter can be broadcast live
Windows 32bit
Windows 64bit
Visit the Conic Show, attend a tea party, or even live house dance.


We map our grants and social investments against our funding priorities. This helps us monitor and learn from our funding over time. It allows us to spot and understand emerging trends in the underlying sector and will also help guide our decisions around exit.
The Charity exists and operates for public benefit. Through our grant making we aim to improve life chances for people in the UK.
The Trustees have referred to the Charity Commission’s general guidance on public benefit when reviewing the Charity’s aims and objectives and in planning future activities and setting grant making policy for the year.
The purpose of the Strategic Grants is to provide meaningful support for specific project or core costs for a minimum of three (and maximum of six) years. The total value of Strategic Grants awarded between £1.5m - £1.7m per annum although this level will be reviewed in each cycle.
‘Intermediate’ Grants are mid-level grants and made over a 2-3 year period to between 4-6 charities to support a project.
The aim of the Intermediate grants is to help smaller or medium sized charities by providing secure funding for 3 years. This may enable them to promote a new project, seek matching funding or match existing funding. Total value of Intermediate Grants is around £250,000 per annum.
The aim of the Discretionary grants is to help smaller charities without imposing a burden on them. Recipients of Discretionary grants may be considered for Intermediate grants in future but there is no guarantee of further support. No reports are required.
The Charity does not accept unsolicited applications. The Trustees seek out Charities they wish to support and will invite those charities to apply for a grant.
MCT is a charitable company limited by guarantee, incorporated on 17 August 2017 (company registration number 10910936) and registered with the Charity Commissioners as a charity (charity registration number 1174232). MCT’s governing document is the Articles of Association dated 17 August 2017, as amended by Special Resolution dated 23 April 2019.


| NAME | FIRST APPEARANCE | ABILITIES |
|---|---|---|
| Joker | Batman #1 (April 1940) | Criminal mastermind, expert chemist, utilizes weaponized props and toxins |
| Ra's al Ghul | Batman #232 (June 1971) | Genius-level intellect, peak physical conditioning, superior strength and stamina, master martial artist and hand-to-hand combatant for centuries |
| Two face | Detective Comics #66 (August 1942) | Schizoid criminal mastermind obsessed with duality, extensive knowledge in law, experienced hand-to-hand combatant and detective |
| Bane | Batman: Vengeance of Bane 1 (January 1993) | Brilliant military strategist, trained mercenary, peak human physical conditioning, venom enhanced strength and durability |
| Black Mask | Batman #386 (August 1985) | Brilliant tactician and strategist, crime boss with powerful underworld connections, skilled marksman, advanced stamina and endurance |


Date of Table Update:<PHONE_NUMBER>46
| Para Numb1, 9 | FNMOC Id2 - Description | FNMOC units | JMBL units | WMO units | |||
|---|---|---|---|---|---|---|---|
| FNMOC Status3 | WMO Status4 | Full Name | JMBL Id5 | GRIB2 Stats6 | GRIB2 Unit of Time Range7 | GRIB2 Fcst Time8 |
|
| 0 | air_temp - The degree of hotness or coldness measured against a definite scale, in this case for the atmosphere. | K | K | K | |||
| current | operational | air temperature | temperatureAir | ||||
| 0 | max_air_temp - The greatest air temperature in a given period of time. | K | K | K | |||
| current | deprecated | maximum air temperature | temperatureMaximum | 2 | 11 | 1 | |
| 0 | min_air_temp - The lowest air temperature in a given period of time. | K | K | K | |||
| current | deprecated | minimum air temperature | temperatureMinimum | 3 | 11 | 1 | |
| 0 | air_temp_ens_stdev - The standard deviation of the air temperature of the ensemble members for a point in time. | K | none | ||||
| current | operational | air temperature ensemble standard deviation | none | 253 | |||
| 1 | virt_air_temp - Temperature that dry air would have if its pressure and density were equal to those of a given sample of moist air. | K | K | K | |||
| listed | operational | virtual air temperature | temperatureVirtual | ||||
| 2 | ptnl_temp - The temperature an unsaturated parcel of dry air would have if brought adiabatically and reversibly from its initial state to a standard pressure. | K | K | ||||
| listed | operational | potential temperature | temperaturePotential | ||||
| 3 | eq_ptnl_temp - A thermodynamic quantity, with its natural logarithm proportional to the entropy of moist air, that is conserved in a reversible moist adiabatic process. (AMS Glossary) | K | K | ||||
| listed | operational | equivalent potential temperature | none | ||||
| 6 | dwpt_temp - The temperature to which a given parcel of air must be cooled at constant pressure and water vapor content in order for saturation to occur. | K | K | K | |||
| listed | operational | dewpoint temperature | temperatureDewpoint | ||||
| 7 | dwpt_dprs - The quantity of difference between the air temperature and the dewpoint temperature. | K | K | K | |||
| current | operational | dewpoint depression | temperatureDewpointDepression | ||||
| 8 | temp_lapse_rate - The decrease of atmospheric temperature with height. | deg_K/m | deg_K/m | deg_K/m | |||
| current | operational | temperature lapse rate | temperatureLapseRate | ||||
| 9 | temp_anom - The deviation of temperature in a given region over a specified period from the long-term average value for the same region (AMS Glossary). | K | K | K | |||
| listed | operational | temperature anomaly | temperatureAnomaly | ||||
| 10 | ltnt_heat_flux - The estimated rate of heat flow per unit mass for a system in a reversible, isobaric-isotheric change of phase. | W/m2 | W/m2 | none | |||
| current | operational | latent heat flux | fluxHeatLatent | ||||
| 11 | snsb_heat_flux - The estimated rate of the flow of heat between two bodies. | W/m2 | W/m2 | ||||
| current | operational | sensible heat flux | fluxHeatSensible | ||||
| 12 | heat_indx - no definition available. | K | K | ||||
| listed | operational | heat index | temperatureHeatIndex | ||||
| 13 | wnd_chill_fctr - no definition available. | K | K | ||||
| listed | operational | wind chill factor | none | ||||
| 15 | vir_ptnl_temp - no definition available. | K | K | ||||
| listed | operational | virtual potential temperature | none | ||||
| 16 | snw_phs_chg_ht_flux - no definition available. | W/m2 | W/m2 | ||||
| listed | operational | snow phase change heat flux | none | ||||
| 17 | skin_temp - no definition available. | K | K | K | |||
| listed | operational | skin temperature | temperatureEarthSkin | ||||
| 18 | snw_temp - The temperature of the top of the snow amassed on a surface. | K | K | K | |||
| listed | validation | snow temperature (top of snow) | temperatureSnow | ||||
| 19 | turb_xfer_coef_heat - no definition available. | numeric | numeric | ||||
| listed | validation | turbulence transfer coefficient for heat | none | ||||
| 20 | turb_diffu_coef_heat - no definition available. | m2/s | m2/s | ||||
| listed | validation | turbulence diffusion coefficient for heat | none | ||||
| 240 | air_temp_err - Analysis air temperature error from truth (observations). | K | K | none | |||
| current | air temperature error | temperatureAirErrorEstimate | 6 | ||||
| 248 | grnd_sea_temp - The temperature at the surface of the ocean and/or land; specifically a bulk temperature of the top layer of the ocean model or the upper most layer of the land model. | K | K | K | |||
| current | operational | ground sea temperature | temperatureLandSea | ||||
| 249 | ttl_heat_flux - The estimated total rate of flow of heat in the atmosphere. | W/m2 | W/m2 | none | |||
| current | total heat flux | fluxHeatTotal | |||||
| 250 | tstar - The ratio of the surface turbulent vertical heat flux to the friction velocity. | K | K | none | |||
| current | scale temperature for surface | temperatureScaleSurface | |||||
| 252 | snsb_ltnt_heat_flux - The rate of transfer of sensible heat (enthalphy) plus latent heat from one region to another. | W/m2 | W/m2 | none | |||
| current | sensible latent heat flux | fluxHeatSensibleAndLatent | |||||
| 254 | temp_dif - The difference between the standard atmosphere temperature (day) at a level and the measured air temperature at the same level. | K | K | none | |||
| current | temperature difference | temperatureAirDifferenceStandard |
Date of Table Creation:<PHONE_NUMBER>26
Date of Last Table Update:<PHONE_NUMBER>46
Authority: Data Standard Control Board
References:
| title: | Product Name Standard Document |
| version: | 2.2 |
| docId: | P-3146-2.2 |
| dtg: | May 2012 |
| organization: | Fleet Numerical Meteorology and Oceanography Center |
| infoUsed: | parameter table |
|
|
|
| title: | GRIB 2 |
| version: | 11.0.0 |
| docId: | FM 92-XII |
| organization: | World Meteorological Organization |
| infoUsed: | GRIB2 Parameter Number by Product Discipline and Parameter Category, table 4.2. |
|
|
|
| title: | Glossary of Meteorology |
| version: | 2.0 |
| docId: | AMS Glossary |
| organization: | American Meteorological Society |
| infoUsed: | various definitions. |
|
|
|
| title: | Webster's Ninth New Collegiate Dictionary |
| version: | 9.0 |
| docId: | ISBN 0-87779-509-6 |
| organization: | Merriam-Webster Inc |
| infoUsed: | various definitions (like air_temp). |
|
|
Footnotes:
| value | definition |
|---|---|
| available | Entry was used in the past, is not in production now, and could be used again. |
| current | Entry is currently in production and available to customers. |
| deprecated | Entry is no longer to be used. May or may not be in production. |
| listed | Entry is listed in WMO documentation. Not in production with no plans to be produced. |
| obsolete | Entry is not to be used and is not in production, if it ever was. |
| pending | Entry is being prepared for production. |
| planned | Entry is being looked at for possible production. |
| value | definition |
|---|---|
| deprecated | Entry is no longer used. |
| experimental | Entry is not recommended for use outside of bi-lateral previously agreed tests. |
| operational | Entry is available for use. |
| validation | Entry is in the approval process. |


System/161 has the ability to collect kernel execution profiles for offline analysis, e.g. with gprof. This is transparent (does not require compiling the kernel with -pg) and independent of the kernel's own execution.
Profiling support is one of the "slow" features available only when running trace161. The -P command-line option enables profile collection; when System/161 shuts down the profile data is written to the file gmon.out. To collect and analyze a basic profile:
trace161 -P kernel gprof kernel | lessThis much is sufficient for many purposes.
The trace control device contains two registers that can be used to manipulate the profiler. If your kernel has a driver for this device, it can turn profile collection on and off dynamically and, when desired, clear the accumulating profile data. This can be used to e.g. exclude bootup activities from a profile, to profile single workloads, or for certain more advanced techniques.
If you have a contended lock, you can get a profile of what happens while that lock is held by enabling profile collection when the lock is acquired and disabling it again when the lock is released. The resulting profile will contain sampling data and call graph data only for code reached while the lock is held; this can often pinpoint problems that are invisible in a full profile.

Finally, you can profile the execution of background threads (syncers, pagers, reapers, etc.) by having the thread switch code enable profiling when the target thread is running.
The statistical profiler samples at 1000 Hz. (This frequency can be cranked up further if necessary by changing PROFILE_NSECS in speed.h and recompiling System/161.) The sampling bins are 16 bytes wide; on MIPS this is only four instructions. As a result of these considerations the profiling results are considerably more precise than gprof believes by default; it is usually reasonable to increase the number of figures in the gprof output. Unfortunately, only some versions of gprof seem to support this.
Currently the sampling profiler samples only from CPU 0. Code running on other CPUs is not sampled. This bug does not apply to the call graph and call counting data; even so, for best results configure only one CPU when profiling.


Posted by Christopher Chou on April 27, 2020
Posted by Christopher Chou on May 2, 2020
Posted by Christopher Chou on May 4, 2020
Posted by Christopher Chou on May 31, 2020
Posted by Christopher Chou on June 13, 2020


Solar Hacks is a one-day, 200-participant Hackathon that is independent and unaffiliated with any school. Our goal is to bring middle and high school students in the Bay Area together to come together and develop innovative ideas that could revolutionize the world. At Solar Hacks, we provide students with the resources and mentorship that would be needed to convert their ideas into a reality. Additionally, by the end of the Hackathon, students will be able to learn how to collaborate with their peers to build STEM projects, gain presentation skills, and be inspired to continue doing things they love! Food, workshops, assistance, drinks, and swag will be provided to all participants for free! We want all participants to enjoy their day at Solar Hacks, hence, we would encourage everybody to arrive to the Hackathon with a competitive mindset.
Event Code of Conduct
All attendees, speakers, sponsors and volunteers at events hosted
at DigitalOcean Headquarters, or events representing DigitalOcean,
are required to agree with the following code of conduct.
Organizers and/or DigitalOcean staff will enforce this code
throughout the event. We are expecting cooperation from all
participants to help ensure a safe environment for everybody.
The Quick Version DigitalOcean is dedicated to providing a
harassment-free event experience for everyone, regardless of
gender, gender identity and expression, age, sexual orientation,
disability, physical appearance, body size, race, ethnicity,
religion (or lack thereof), or technology choices. We do not
tolerate harassment of event participants in any form. Sexual
language and imagery is not appropriate for any event venue,
including talks, workshops, parties, Twitter and other online
media. Event participants violating these rules may be sanctioned
or expelled from the event without a refund at the discretion of
the event organizers or DigitalOcean employees.

Participants asked to stop any harassing behavior are expected to
comply immediately. Sponsors are also subject to the
anti-harassment policy. In particular, sponsors should not use
sexualized images, activities, or other material. Sponsor staff
(including volunteers) should not use sexualised
clothing/uniforms/costumes, or otherwise create a sexualized
environment.
If a participant engages in harassing behavior, the event
organizers or DigitalOcean staff may take any action they deem
appropriate, including warning the offender or expulsion from the
event with no refund.
If you are being harassed, notice that someone else is being
harassed, or have any other concerns, please contact a member of
DigitalOcean or event staff immediately.
DigitalOcean staff will be happy to help participants contact
venue security or local law enforcement, provide escorts, or
otherwise assist those experiencing harassment to feel safe for
the duration of the event. We value your attendance. We expect
participants to follow these rules at all DigitalOcean related
event venues.
Original source and credit:
http://2012.jsconf.us/#/about
& The Ada Initiative


I am collecting my data from 3 cts + 1 ac-ac adaptor connected to an emonTx with emonTxV3_4chan_continuous fw, it is connected to emoncms through Nanode with NanodeRF_multinode, my emoncms uid is mpower.
My readings are significantly inaccurate.
First: I have 3 CTs connected to Node:10, name 2, 3 & 4; nevertheless I am getting an input on name 5, even with ALL CTs disconnected, i still keep getting an input on name 5. Can you assist in troubleshooting this??
Second: From reading the code, i understand that name 1 field is the msgNumber value, is this correct, then what is the point of transmitting the msgNumber value??
Third: I am logging the input in Node: 10 name 2 and converting this feed to power, I am getting significantly wide readings compared to my mains meter reader, e.g at the moment, Node 10 name 2 is reading value of 42, while my mains meter is showing a consumption of 290 watts. What could be causing the wide discrepancy??
Fourth: My other two connected CTs may not be accurate or close to accurate as well. as comparing the inputs and load connected to them. Could you please advise on how i can verify the readings??
Re: SIGNIFICANTLY INACCURATE emonTxV3_4chan_continuous
We have not properly tested or calibrated the 4chan_continuous code on the emonTx V3 as is stated in the comment at the beginning of the sketch. The main firmware we have released with the emonTx V3 is the discrete sampling https://github.com/openenergymonitor/emonTxFirmware/tree/master/emonTxV3/RFM12B/emonTxV3_RFM12B_DiscreteSampling. Please contribute back if you do manage to calibrate the continuous sampling. I will try and make this more clear in the gitHub readme
Re: SIGNIFICANTLY INACCURATE emonTxV3_4chan_continuous
Github readme documents have now been updated
Re: SIGNIFICANTLY INACCURATE emonTxV3_4chan_continuous
Hello mpower, I have fixed and updated the calibration constants in the example, the calibration constants now use the theoretical calibration value determined from the component values. The updated example is up here:
https://github.com/openenergymonitor/emonTxFirmware/blob/master/emonTxV3...
Lines 113 to 118 now read:
const float powerCal_CT1 = (276.9*(3.3/1023))*(90.9*(3.3/1023)); // <---- powerCal value
const float powerCal_CT2 = (276.9*(3.3/1023))*(90.9*(3.3/1023)); // <---- powerCal value
const float powerCal_CT3 = (276.9*(3.3/1023))*(90.9*(3.3/1023)); // <---- powerCal value
const float powerCal_CT4 = (276.9*(3.3/1023))*(16.6*(3.3/1023)); // <---- powerCal value (2000 / 120R burden resistor)
To add: the channels read a little high when no CT is connected but if the CT is plugged in and no power is flowing the measurement does go to zero.
Edit: Voltage calibration constant was also incorrect and has been updated to 276.9 which is the calibration constant as determined theoretically (230V x 13) / (9V x 1.2) = 276.9. Where 13 is the voltage divider reduction factor and 1.2 accounts for 20% increase in voltage adapter output voltage as its not being loaded (open circuit)
The measurements are now agreeing within 5-10W @ 3kW with my reference meter here.
Re: SIGNIFICANTLY INACCURATE emonTxV3_4chan_continuous
Thanks guys for the updates; I am getting ~10 - 12W @ <0.2kW when compared to the billing meter.
Anybody using the emonTx V2 should remember to set the pins correctly.
----------------------------------------------------------------------------------------------------
// analogue input pins (for emonTx V2):
const byte voltageSensor = 2; // analogue
const byte currentSensor_CT1 = 3; // analogue
const byte currentSensor_CT2 = 0; // analogue
const byte currentSensor_CT3 = 1; // analogue
const byte currentSensor_CT4 = 4; // analogue
-----------------------------------------------------------------------------------------------------
Could you please confirm if the below convention also valid for the emonTx V2??
--------------------------------------------------------------------------------------------------------------------------------------------------------------
//emonTxV3 CT channel will read ADC 0 when nothing is connected due to switched jack plugs connecting ADC to 0V when no jack is inserted
if (analogRead(1) > 0) CT1 = 1; //check to see if CT is connected to CT1 input, if so enable that channel
if (analogRead(2) > 0) CT2 = 1; //check to see if CT is connected to CT2 input, if so enable that channel
if (analogRead(3) > 0) CT3 = 1; //check to see if CT is connected to CT3 input, if so enable that channel
if (analogRead(4) > 0) CT4 = 1; //check to see if CT is connected to CT4 input, if so enable that channel
---------------------------------------------------------------------------------------------------------------------------------------------------------------
Finally i tried to UNSUCCESFULLY to add collecting of Vrms in emonTxV3_4chan_continuous by adding the following bits within the code. Do you have any hints on how i can get it to work??
____________________________________________________________________________________________
#include "EmonLib.h" // Include Emon Library |
EnergyMonitor ct1;
/*
typedef struct { byte dumpState; int msgNumber; } Tx_struct; // data for RF comms
Tx_struct tx_data;
*/
typedef struct {
int msgNumber;
int Vrms;
int power_CT1;
int power_CT2;
int power_CT3;
int power_CT4; } Tx_struct; // revised data for RF comms
Tx_struct tx_data;
void allGeneralProcessing()
{
static int samplesDuringThisCycle; // for normalising the power in each mains cycle
static long sumP_CT1; // for per-cycle summation of 'real power'
static long sumP_CT2; // for per-cycle summation of 'real power'
static long sumP_CT3; // for per-cycle summation of 'real power'
static long sumP_CT4; // for per-cycle summation of 'real power'
static enum polarities polarityOfLastSampleV; // for zero-crossing detection
static long cumVdeltasThisCycle_long; // for the LPF which determines DC offset (voltage)
static long lastSampleVminusDC_long; // for the phaseCal algorithm
static int Vrms;
static int msgNumber = 0;
if ((cycleCount % 50) == 0)
{
tx_data.msgNumber = msgNumber++; // increment
tx_data.Vrms = ct1.Vrms*100;
tx_data.power_CT1 = energyInBucket_long_CT1 * (powerCal_CT1/50);
tx_data.power_CT2 = energyInBucket_long_CT2 * (powerCal_CT2/50);
tx_data.power_CT3 = energyInBucket_long_CT3 * (powerCal_CT3/50);
tx_data.power_CT4 = energyInBucket_long_CT4 * (powerCal_CT4/50);
send_rf_data();
Serial.print(tx_data.power_CT1);
energyInBucket_long_CT1 = 0;
Serial.print(", ");
Serial.print(tx_data.power_CT2);
energyInBucket_long_CT2 = 0;
Serial.print(", ");
Serial.print(tx_data.power_CT3);
energyInBucket_long_CT3 = 0;
Serial.print(", ");
Serial.print(tx_data.power_CT4);
energyInBucket_long_CT4 = 0;
Serial.print(", ");
Serial.println(tx_data.Vrms);
Serial.print(", ");
Serial.println(samplesDuringThisCycle);
digitalWrite(LedPin, tx_data.msgNumber & 0x01);
_______________________________________________________________________________________|
Re: SIGNIFICANTLY INACCURATE emonTxV3_4chan_continuous
First, anyone with an emonTx V2 should stay with the emonTxV2 sketches - these are tried and tested on the V2, else as you point out the pin allocations are wrong. The convention for turning on various sections of code has changed over time so it's not safe to make general assumptions, you need to look at and understand the particular sketch.
Second, your Vrms problem: In what way is it not working? Is there a sensible value in ct1.Vrms? You might like to look at RFM12B - Part 2 - Sending Data Between Modules.


| Home | Trees | Indices | Help |
|---|
|
|
object --+ | ViewObjectBag
A managed collection of view objects.
|
|||
|
|||
|
|||
|
|||
|
|||
|
Inherited from |
|
|||
|
Inherited from |
|
Initialise a ViewObjectBag, with a given collection of model objects and a class of view object. :Parameters: `targets` : iterable An iterable of model objects which are to be handled. `viewerclass` : class The class of view object with which to handle the model objects.
|
Update the list of view objects, creating and destroying objects as necessary. Tick each of the view objects within the bag. |
| Home | Trees | Indices | Help |
|---|
| Generated by Epydoc 3.0.1 on Fri Feb 29 22:59:33 2008 | http://epydoc.sourceforge.net |


Login To LinkedIn
Logout of LinkedIn
Fetch Profile
First name:
{{firstName}}
Last name:
{{lastName}}
Title:
{{headline}}


--- layout: error ---
This page is either under construction or doesn't exist anymore.
Let's go back home.


public interface Audio
| Modifier and Type | Method and Description |
|---|---|
int |
getBufferID()
Get the ID of the OpenAL buffer holding this data (if any).
|
float |
getPosition()
Return the current playing position in the sound
|
boolean |
isPlaying()
Check if the sound is playing as sound fx
|
int |
playAsMusic(float pitch,
float gain,
boolean loop)
Play this sound as music
|
int |
playAsSoundEffect(float pitch,
float gain,
boolean loop)
Play this sound as a sound effect
|
int |
playAsSoundEffect(float pitch,
float gain,
boolean loop,
float x,
float y,
float z)
Play this sound as a sound effect
|
boolean |
setPosition(float position)
Seeks to a position in the music.
|
void |
stop()
Stop the sound effect
|
void stop()
int getBufferID()
boolean isPlaying()
int playAsSoundEffect(float pitch, float gain, boolean loop)
pitch
- The pitch of the play backgain
- The gain of the play backloop
- True if we should loopint playAsSoundEffect(float pitch, float gain, boolean loop, float x, float y, float z)
pitch
- The pitch of the play backgain
- The gain of the play backloop
- True if we should loopx
- The x position of the soundy
- The y position of the soundz
- The z position of the soundint playAsMusic(float pitch, float gain, boolean loop)
pitch
- The pitch of the play backgain
- The gain of the play backloop
- True if we should loopboolean setPosition(float position)
position
- Position in seconds.float getPosition()


Australia
My parents took us to Australia and New Zealand when me and my sister were very young. Here I am petting a kangaroo.
Borneo
Here are some photos of the time we went to Borneo. I was pretty young and don't remember much, but I do remember the Orangutangs
Ecuador
I went to Quito, Ecuador for a month as part of a language immersion program. Here is a view of the city as seen from the hills. Quito is cool,
I had fun there


Hi ! I am Sibil Sarjam Soren, an Web Development Enthusiast, Seeking oppourtunities to enhance and explore my knowledge in building complete end-to-end Web Application projects.
I love learning new Technologies and I love playing Basketball
View ResumeThis project is inspired by Google Keep notes, In which a user adds notes and can edit, delete notes. and the data gets saved locally, So that whenever the user again uses the app the data persists.
This project is just a static web page, which is made using HTML, CSS and Bootstrap, The main focus for this project to make responsive web design and creating layout as per the design provided
This is one of the interesting project, In which we have used React along with a API which detect he face using AI , The main focus in this project was to give image as an input and recieve the detected face region and display in the UI over the image.
Let's connect !
Email<EMAIL_ADDRESS>Phone: +91 -<PHONE_NUMBER>


[1]
-amazing photo quality. -good kit lens. -compatible with past non-digital lenses; -not great button placement
[2]
very well made and excellent picture quality; Video mode not available through view finder


{% extends 'base.html' %} {% load crispy_forms_tags %} {% block title %}Account{% endblock %} {% block content %}
You can have mulptiple accounts. When creating an account you will automatically be added as its Administrator. You can
give other users access to the account in the account settings.
Please note that, account names must be unique throughout the whole Stencila Hub.


Note: The "Read Only" toggle will only affect elements with
text <input />
elements. If there is an underlying
<select />
element, this will remain editable, since
these elements do not support the readonly
property in HTML5.
Thus only the combo-selects, auto-completes and date-select will be affected,
and only the date-select will have it's drop-down disabled.


{% load i18n %}
{% include "include/pick_lang.html" %}
{% include "include/get_title.html" %}
{% block delete_note%}
{% comment %}commented out temporaily. There seems to be some problem in deleting notes.
{% if user.username == profile_username %}
{% if note.deleted %}
{% else %}
{% endif %}
{% endif %}
{% endcomment %}
{% endblock %}
{% block note_desc%}
{% include "include/get_desc.html" %}
{% endblock %}
{% block note_url%}
{% endblock %}
{% block note_tags%} {% comment %} below added a lot of div or span with class or id in order to use the same js for notes display {% endcomment %}