+++
title = "OMARSdocs"
linkTitle = "OMARSdocs"
+++
{{< blocks/cover title="Welcome to OMARSdocs: experimental designs for everyone! " image_anchor="top" height="full" color="orange" >}}
{{< /blocks/cover >}}
{{% blocks/lead color="primary" %}}
Whether you need an experimental design for screening, knowledge discovery or optimization, you have landed at the right place!
OMARSdocs provides not only online documentation of the OMARS software for design selection,
but also a complete statistical theoretical background on related statistical concepts.
Here, you can even find out real examples of applications who have benefit from O-MARS discovery!
{{% /blocks/lead %}}
{{< blocks/section color="dark" >}}
{{% blocks/feature icon="fas fa-chart-line" title="We have added new OMARS designs to the database!" %}}
Click here to discover what's new.
Please follow this space for updates!
{{% /blocks/feature %}}
{{% blocks/feature icon="far fa-comments" title="Comments are welcome!" url="https://github.com/google/docsy-example" %}}
Please leave your thoughts on this site at the [Comments]("/comments") section :)
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-twitter" title="Follow us on Twitter!" url="https://twitter.com/docsydocs" %}}
For announcement of latest features etc.
{{% /blocks/feature %}}
{{< /blocks/section >}}
{{< blocks/section >}}
This is the second Section
{{< /blocks/section >}}
{{< blocks/section >}}
{{% blocks/feature icon="fab fa-app-store-ios" title="Download **from AppStore**" %}}
Get the Goldydocs app!
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-github" title="Contributions welcome!" url="https://github.com/google/docsy-example" %}}
We do a [Pull Request](https://github.com/google/docsy-example/pulls) contributions workflow on **GitHub**. New users are always welcome!
{{% /blocks/feature %}}
{{% blocks/feature icon="fab fa-twitter" title="Follow us on Twitter!" url="https://twitter.com/GoHugoIO" %}}
For announcement of latest features etc.
{{% /blocks/feature %}}
{{< /blocks/section >}}
{{< blocks/section >}}
This is another Section
{{< /blocks/section >}}


| Feedback |
This tutorial presents two sample applications to demonstrate the use of the Java GSS-API. This API permits secure exchanges of messages between communicating applications. Here are the sample client and server applications you'll need for this tutorial:
This tutorial uses policy files and a more complex login configuration file. The programs are run with a security manager; as a result, security-sensitive operations are not allowed unless the required permissions were explicitly granted. This tutorial also demonstrates how JAAS authorization adds user-centric access control that applies control based on who is running the code--not just on what code is running.
Note: This tutorial uses the same client and server applications as the Use of JavaTM GSS-API for Secure Message Exchanges Without JAAS Programming tutorial. In that tutorial, JAAS (JavaTM Authentication and Authorization Service) programming is not required. Instead, you let the underlying mechanism decide how to get credentials.
SampleServer
Programs
In this Java GSS-API tutorial, the first step is JAAS authentication. Previous tutorials demonstrated the use of JAAS for user authentication and authorization, and presented examples of policy files and of login configuration files (specifying the underlying authentication technology to be used) that JAAS requires. Applications in the JAAS introductory tutorials, JAAS Authentication and JAAS Authorization, made direct calls to JAAS methods. The Use of JAAS Login Utility tutorial showed the use of a utility program that frees the application from having to do this. The client and server applications in the current tutorial also use the same utility program, so we recommend you read the login utility tutorial first.As with all tutorials in this series, the underlying technology used to support authentication and secure communication for the applications in this tutorial is Kerberos. See Kerberos Requirements.
The applications for this tutorial are named
SampleClient
andSampleServer
.Each is invoked by executing the Login utility supplied with this tutorial and passing it as arguments the name of the application (
SampleClient
orSampleServer
), followed by the arguments needed by the application. The Login utility uses a JAAS LoginContext to authenticate the user using Kerberos. Finally, the Login utility invokes themain
method of the application class, in our case eitherSampleClient
orSampleServer
, and passes the application its arguments.Here is a summary of execution of the
SampleClient
andSampleServer
applications:
- Run the
SampleServer
application by running the Login utility and passing it as arguments the name "SampleServer
" followed by the arguments for theSampleServer
program. The Login utility prompts you for the password for the principal thatSampleServer
should run as. (See Kerberos User and Service Principal Names.) After authentication is complete,SampleServer
is run it:
- Reads its argument, the port number that it should listen on for client connections.
- Creates a ServerSocket for listening for client connections on that port.
- Listens for a connection.
- Run the
SampleClient
application (possibly on a different machine), by running the Login utility and passing it as arguments the name "SampleClient
" followed by the arguments for theSampleClient
program. The Login utility prompts you for your Kerberos name and password. After authentication is complete,SampleClient
is run. It
- Reads its arguments: (1) The name of the Kerberos principal that represents
SampleServer
. (See Kerberos User and Service Principal Names.), (2) the name of the host (machine) on whichSampleServer
is running, and (3) the port number on whichSampleServer
listens for client connections.
- Attempts a socket connection with the
SampleServer
, using the host and port it was passed as arguments.
- The socket connection is accepted by
SampleServer
and both applications initialize a DataInputStream and a DataOutputStream from the socket input and output streams, to be used for future data exchanges.
SampleClient
andSampleServer
each instantiate a GSSContext and establish a shared context that will enable subsequent secure data exchanges.
SampleClient
andSampleServer
can now securely exchange messages.
- When
SampleClient
andSampleServer
are done exchanging messages, they perform clean-up operations.
Note: Refer to "TheSampleClient
andSampleServer
Code" section of the Use of JavaTM GSS-API for Secure Message Exchanges Without JAAS Programming tutorial for a full discussion of the code used in this tutorial.
Kerberos User and Service Principal Names
Since the underlying authentication and secure communication technology used by this tutorial is Kerberos V5, we use Kerberos-style principal names wherever a user or service is called for.
For example, when you run
SampleClient
you are asked to provide your user name. Your Kerberos-style user name is simply the user name you were assigned for Kerberos authentication. It consists of a base user name (like "mjones") followed by an "@" and your realm (like "mjones@KRBNT-OPERATIONS.ABC.COM").A server program like
SampleServer
is typically considered to offer a "service" and to be run on behalf of a particular "service principal." A service principal name forSampleServer
is needed in several places:
- When you run
SampleServer
you must log in as the appropriate service principal. The login configuration file for this tutorial actually specifies the service principal name (as an option to the Krb5LoginModule), so the JAAS authentication (done by the Login utility) just asks you to specify the password for that service principal. If you specify the correct password, the authentication is successful, a Subject is created containing a Principal with the service principal name, and that Subject is associated with a new access control context. The subsequently-executed code (theSampleServer
code) is considered to be executed on behalf of the specified principal.
- When you run
SampleClient
, one of the arguments is the service principal name. This is needed soSampleClient
can initiate establishment of a security context with the appropriate service.
- The client and server policy files each require a ServicePermission with name equal to the service principal name and action equal to "initiate" or "accept" (for initiating or accepting establishment of a security context).
Throughout this document, and in the accompanying login configuration file and policy files,
is used as a placeholder to be replaced by the actual name to be used in your environment. Any Kerberos principal can actually be used for the service principal name. So for the purposes of trying out this tutorial, you could use your user name as both the client user name and the service principal name.service_principal@your_realmIn a production environment, system administrators typically like servers to be run as specific principals only and may assign a particular name to be used. Often the Kerberos-style service principal name assigned is of the form
service_name/machine_name@realm;For example, an nfs service run on a machine named "raven" in the realm named "KRBNT-OPERATIONS.ABC.COM" could have the service principal name
<EMAIL_ADDRESS>multi-component names are not required, however. Single-component names, just like those of user principals, can be used. For example, an installation might use the same ftp service principal
ftp@realm
for all ftp servers in that realm, while another installation might have different ftp principals for different ftp servers, such asftp/host1@realm
andftp/host2@realm
on machineshost1
andhost2
, respectively.When the Realm is Required in Principal Names
If the realm of a user or service principal name is the default realm (see Kerberos Requirements), you can leave off the realm when you are logging into Kerberos (that is, when you are prompted for your username). Thus, for example, if your user name is<EMAIL_ADDRESS>and you run
SampleClient
, when it requests your user name you could just specify "mjones", leaving off the realm. The name is interpreted in the context of being a Kerberos principal name and the default realm is appended, as needed.You can also leave off the realm if a principal name will be converted to a GSSName by a GSSManager
createName
method. For example, when you runSampleClient
, one of the arguments is the server service principal name. You can specify the name without including the realm, becauseSampleClient
passes the name to such acreateName
method, which appends the default realm as needed.It is recommended that you always include realms when principal names are used in login configuration files and policy files, because the behavior of the parsers for such files may be implementation-dependent; they may or may not append the default realm before such names are utilized and subsequent actions may fail if there is no realm in the name.
The Login Configuration File
Whenever JAAS is used, a login configuration is required to specify the desired authentication technology. (See JAAS Login Configuration File for more information about what a login configuration file is.) Both
SampleClient
andSampleServer
can use the same login configuration file, if that file contains two entries, one entry for the client side and one for the server side.The csLogin.conf login configuration file used for this tutorial is the following:
SampleClient { com.sun.security.auth.module.Krb5LoginModule required; }; SampleServer { com.sun.security.auth.module.Krb5LoginModule required storeKey=true principal="service_principal@your_realm"; };Note that the name for each entry matches the respective class names for our two top-level applications,
SampleClient
andSampleServer
. Recall that this is also the name that is passed to the Login utility that performs JAAS operations for the application. That utility expects the name of the entry to be looked up in your login configuration file to be the same as the name it is passed.Both entries specify that Sun's Kerberos V5 LoginModule must be used to successfully authenticate the user. The Krb5LoginModule succeeds only if the attempt to log in to the Kerberos KDC as a specified entity is successful. In the case of
SampleClient
, the user will be prompted for their name and password. In the case ofSampleServer
, a name is already supplied in this login configuration file (the specified principal, as described below) and the user runningSampleServer
is just asked for the password for the entity specified by that name. They must specify the correct password in order for authentication to succeed.The
SampleServer
entrystoreKey=true
indicates that a secret key should be calculated from the password provided during login and it should be stored in the private credentials of the Subject created as a result of login. This key is subsequently utilized during mutual authentication when establishing a security context betweenSampleClient
andSampleServer
.The Krb5LoginModule has a
principal
option that can be used to specify that only the specified principal (entity/user) should be logged in for the given program. Here, theSampleClient
entry does not specify a principal (although it could, if desired), so the user is prompted for a user name and password and anyone with a valid user name and password can runSampleClient
.SampleServer
, on the other hand, indicates a particular principal because system administrators usually like servers to be run as specific principals only. In this case, the user runningSampleServer
is prompted for that principal's password and must supply the correct one in order for authentication to succeed.Note that you must replace "service_principal@your_realm" with the name of the service principal that represents
SampleServer
. (See Kerberos User and Service Principal Names.)For information about all the possible options that can be passed to Krb5LoginModule, see the Krb5LoginModule documentation.
The Policy Files
The policy file used when running
SampleClient
is client.policy, and the policy file used when runningSampleServer
is server.policy. Their contents are described below.The Client Policy File
Permissions Required by the Login utility Classes
A number of permissions are required by the classes in
Login.java
(Login and MyAction). As recommended in the previous tutorial on the use of Login, we create aLogin.jar
JAR file containing theLogin.class
andMyAction.class
files and in theclient.policy
policy file we grantLogin.jar AllPermission
:grant codebase "file:./Login.jar" { permission java.security.AllPermission; };Permissions Required by
SampleClient
The
SampleClient
code does two types of operations for which permissions are required. It
- opens a socket connection with the host machine running the
SampleServer
application.
- initiates establishment of a security context with
SampleServer
.The permission required to open a socket connection is
permission java.net.SocketPermission "*", "connect";You may replace the "*" with the hostname or IP address of the machine that
SampleServer
will be running on.The permission(s) required to initiate establishment of a security context will depend on the underlying mechanism. This tutorial uses Kerberos as the underlying mechanism, and for that two
javax.security.auth.kerberos.ServicePermission
s are required. A ServicePermission contains a service principal name and an action (or list of actions). To initiate establishment of a security context, you need two ServicePermissions with action "initiate", whose names specify:
- the service principal name for the ticket granting service for your realm. Granting this permission essentially allows the use of Kerberos as a client.
- the service principal name representing
SampleServer
. (See Kerberos User and Service Principal Names.) Granting this permission allows you to interact with the service,SampleServer
, using Kerberos.We want to grant the permissions to a specific authenticated user executing
SampleClient
, so we specify both theSampleClient
code location (inSampleClient.jar
) and a Principal designation indicating the user name and realm for the user (you, the person who will runSampleClient
). (See How Do You Make Principal-Based Policy File Statements? in the second tutorial of this series for information on policy filegrant
statements that include Principal designations.)Here is the basic form for the
grant
statement:grant CodeBase "file:./SampleClient.jar", Principal javax.security.auth.kerberos.KerberosPrincipal "your_user_name@your_realm" { permission java.net.SocketPermission "*", "connect"; permission javax.security.auth.kerberos.ServicePermission "krbtgt/your_realm@your_realm", "initiate"; permission javax.security.auth.kerberos.ServicePermission "service_principal@your_realm", "initiate"; };You must substitute your Kerberos user name (complete with "@" and realm) for "
your_user_name@your_realm
". For example, if your user name is "mjones" and your realm is "KRBNT-OPERATIONS.ABC.COM", you would use<EMAIL_ADDRESS>(complete with the quotes).You must also substitute your realm in "krbtgt/your_realm@your_realm" and the service principal name for the service principal representing the server for "
service_principal@your_realm
". Suppose the former is<EMAIL_ADDRESS>and the latter is<EMAIL_ADDRESS>and your user name is as specified in the previous paragraph. Then thegrant
statement would begrant CodeBase "file:./SampleClient.jar", Principal javax.security.auth.kerberos.KerberosPrincipal<EMAIL_ADDRESS>{ permission java.net.SocketPermission "*", "connect"; permission javax.security.auth.kerberos.ServicePermission<EMAIL_ADDRESS>"initiate"; permission javax.security.auth.kerberos.ServicePermission<EMAIL_ADDRESS>"initiate"; };The Server Policy File
Permissions Required by the Login Utility Classes
The
grant
statement in the server policy file for the Login classes is exactly the same as the one in the client policy file, as described in Permissions Required by the Login Utility Classes:grant codebase "file:./Login.jar" { permission java.security.AllPermission; };Permissions Required by
SampleServer
The
SampleServer
code does two types of operations for which permissions are required. It
- accepts socket connections.
- accepts establishment of a security context, that is, it is the "acceptor" for security context establishment.
The permission required to accept socket connections is
permission java.net.SocketPermission "*", "accept";You may replace the "*" with the hostname or IP address of the machine that
SampleClient
will be running on.The permission required to accept establishment of a security context is
where "service_principal@your_realm" is the Kerberos name of the service principal that representspermission javax.security.auth.kerberos.ServicePermission "service_principal@your_realm", "accept";SampleServer
.We want to grant the permissions to a specific authenticated user executing
SampleServer
(the service principal considered to representSampleServer
), so we specify both theSampleServer
code location (inSampleServer.jar
) and a Principal designation indicating the service principal. Suppose this name is<EMAIL_ADDRESS>Then thegrant
statement would begrant CodeBase "file:./SampleServer.jar" Principal javax.security.auth.kerberos.KerberosPrincipal<EMAIL_ADDRESS>{ permission java.net.SocketPermission "*", "accept"; permission javax.security.auth.kerberos.ServicePermission<EMAIL_ADDRESS>"accept"; };Running the
SampleClient
andSampleServer
ProgramsTo execute the
SampleClient
andSampleServer
programs, do the following:
- Prepare
SampleServer
for Execution
- Prepare
SampleClient
for Execution
- Execute
SampleServer
- Execute
SampleClient
Prepare
SampleServer
for ExecutionTo prepare
SampleServer
for execution, do the following:
- Copy the following files into a directory accessible by the machine on which you will run
SampleServer
:
- The Login.java source file.
- The SampleServer.java source file.
- The csLogin.conf login configuration file.
- The server.policy policy file.
- Replace "service_principal@your_realm" in
csLogin.conf
with the name of the service principal representingSampleServer
.
- In both places it appears, replace "service_principal@your_realm" in
server.policy
with the Kerberos name of the service principal that representsSampleServer
. (The same name as that used in the login configuration file.)
- Compile
Login.java
andSampleServer.java
:javac Login.java SampleServer.javaNote that
Login.java
contains two classes and thus compilingLogin.java
createsLogin.class
andMyAction.class
.
- Create a JAR file named
Login.jar
containingLogin.class and MyAction.class
:jar -cvf Login.jar Login.class MyAction.class- Create a JAR file named
SampleServer.jar
containingSampleServer.class
:jar -cvf SampleServer.jar SampleServer.classPrepare
SampleClient
for ExecutionTo prepare
SampleClient
for execution, do the following:
- Copy the following files into a directory accessible by the machine on which you will run
SampleClient
:
- The Login.java source file.
- The SampleClient.java source file.
- The csLogin.conf login configuration file.
- The client.policy policy file.
- Replace parts of
client.policy
:
- replace "your_user_name@your_realm" with your user name and realm.
- replace
your_realm
in "krbtgt/your_realm@your_realm" with your realm.
- replace "service_principal@your_realm" with the Kerberos name of the service principal that represents
SampleServer
.
- Compile
Login.java
andSampleClient.java
:javac Login.java SampleClient.java- Create a JAR file named
Login.jar
containingLogin.class and MyAction.class
:jar -cvf Login.jar Login.class MyAction.class- Create a JAR file named
SampleClient.jar
containingSampleClient.class
:jar -cvf SampleClient.jar SampleClient.classExecute
SampleServer
It is important to execute
SampleServer
beforeSampleClient
becauseSampleClient
will try to make a socket connection toSampleServer
and that will fail ifSampleServer
is not yet running and accepting socket connections.To execute
SampleServer
, be sure to run it on the machine it is expected to be run on. This machine name (host name) is specified as an argument toSampleClient
. The service principal name appears in several places, including the login configuration file and the policy files.Go to the directory in which you have prepared
SampleServer
for execution. Execute theLogin
class, specifying
- by an appropriate
-classpath
clause that classes should be searched for in theLogin.jar
andSampleServer.jar
JAR files,
- by
-Djava.security.manager
that a security manager should be installed,
- by
-Djava.security.krb5.realm=<your_realm>
that your Kerberos realm is the one specified. For example, if your realm is "KRBNT-OPERATIONS.ABC.COM" you'd put-Djava.security.krb5.realm=KRBNT-OPERATIONS.ABC.COM
.
- by
-Djava.security.krb5.kdc=<your_kdc>
that your Kerberos KDC is the one specified. For example, if your KDC is "samplekdc.abc.com" you'd put-Djava.security.krb5.kdc=samplekdc.abc.com
.
- by
-Djava.security.policy=server.policy
that the policy file to be used isserver.policy
, and
- by
-Djava.security.auth.login.config=csLogin.conf
that the login configuration file to be used iscsLogin.conf
.You pass the name of your application (in this case, "
SampleServer
") as an argument to Login. You then add as arguments any arguments required by your application, which in the case ofSampleServer
is a single argument specifying the port number to be used for listening for client connections. Choose a high port number unlikely to be used for anything else. An example would be something like 4444.Below are the full commands to use for both Microsoft Windows and Unix systems. The only difference is that on Microsoft Windows systems you use semicolons to separate classpath items, while you use colons for that purpose on Unix systems.
Important: In these commands, you must replace
<port_number>
with an appropriate port number,<your_realm>
with your Kerberos realm, and<your_kdc>
with your Kerberos KDC.Here is the command for Microsoft Windows systems:
java -classpath Login.jar;SampleServer.jar -Djava.security.manager -Djava.security.krb5.realm=<your_realm> -Djava.security.krb5.kdc=<your_kdc> -Djava.security.policy=server.policy -Djava.security.auth.login.config=csLogin.conf Login SampleServer <port_number>Here is the command for UNIX systems:
java -classpath Login.jar:SampleServer.jar -Djava.security.manager -Djava.security.krb5.realm=<your_realm> -Djava.security.krb5.kdc=<your_kdc> -Djava.security.policy=server.policy -Djava.security.auth.login.config=csLogin.conf Login SampleServer <port_number>Type the full command on one line. Multiple lines are used here for legibility. If the command is too long for your system, you may need to place it in a .bat file (for Microsoft Windows) or a .sh file (for UNIX) and then run that file to execute the command.
You will be prompted for the Kerberos password for the service principal. The underlying Kerberos authentication mechanism specified in the login configuration file will log the service principal into Kerberos. Once authentication is successfully completed, the
SampleServer
code will be executed on behalf of the service principal. It will listen for socket connections on the specified port.For login troubleshooting suggestions, see Troubleshooting.
Execute
SampleClient
To execute
SampleClient
, go to the directory in which you have preparedSampleClient
for execution. Then execute theLogin
class, specifying
- by an appropriate
-classpath
clause that classes should be searched for in theLogin.jar
andSampleClient.jar
JAR files,
- by
-Djava.security.manager
that a security manager should be installed,
- by
-Djava.security.krb5.realm=<your_realm>
that your Kerberos realm is the one specified.
- by
-Djava.security.krb5.kdc=<your_kdc>
that your Kerberos KDC is the one specified.
- by
-Djava.security.policy=client.policy
that the policy file to be used isclient.policy
, and
- by
-Djava.security.auth.login.config=csLogin.conf
that the login configuration file to be used iscsLogin.conf
.Pass to Login the name of your application ("
SampleClient
") followed by the arguments required bySampleClient
. TheSampleClient
arguments are (1) the Kerberos name of the service principal that representsSampleServer
, (2) the name of the host (machine) on whichSampleServer
is running, and (3) the port number on whichSampleServer
is listening for client connections.Below are the full commands to use for both Microsoft Windows and Unix systems.
Important: In these commands, you must replace
<service_principal>
,<host>
,<port_number>
,<your_realm>
, and<your_kdc>
with appropriate values (and note that the port number must be the same as the port number passed as an argument toSampleServer
). These values need not be placed in quotes.Here is the command for Microsoft Windows systems:
java -classpath Login.jar;SampleClient.jar -Djava.security.manager -Djava.security.krb5.realm=<your_realm> -Djava.security.krb5.kdc=<your_kdc> -Djava.security.policy=client.policy -Djava.security.auth.login.config=csLogin.conf Login SampleClient <service_principal> <host> <port_number>Here is the command for UNIX systems:
java -classpath Login.jar:SampleClient.jar -Djava.security.manager -Djava.security.krb5.realm=<your_realm> -Djava.security.krb5.kdc=<your_kdc> -Djava.security.policy=client.policy -Djava.security.auth.login.config=csLogin.conf Login SampleClient <service_principal> <host> <port_number>Type the full command on one line. Multiple lines are used here for legibility. As with the command for executing
SampleServer
, if the command is too long to type directly into your command window, place it in a .bat file (Microsoft Windows) or a .sh file (UNIX) and then execute that file.When prompted, type your Kerberos user name and password. The underlying Kerberos authentication mechanism specified in the login configuration file will log you into Kerberos. Once authentication is successfully completed, the
SampleClient
code will be executed on behalf of you. It will request a socket connection withSampleServer
. OnceSampleServer
accepts the connection,SampleClient
andSampleServer
establish a shared context and then exchange messages as described in this tutorial.For login troubleshooting suggestions, see Troubleshooting.
Feedback


--- layout: post status: publish published: true title: I'm on the list of Virtualization Blogs. Woot! author: display_name: iguy login: iguy email<EMAIL_ADDRESS>url: '' author_login: iguy author_email<EMAIL_ADDRESS>wordpress_id: 549 wordpress_url: http://itsjustanotherlayer.com/?p=549 date: !binary |- MjAxMC0wOS0yOSAxMjoyMjo1NSAtMDUwMA== date_gmt: !binary |- MjAxMC0wOS0yOSAxNzoyMjo1NSAtMDUwMA== categories: - VMware tags: - blogging - Virtualization - VMware comments: [] ---
Eric Siebert, of vSphere-land.com fame, has published the Top 25 blog list of 2010. If you look through the list there is some awesome bloggers out there. I take great pride in having met some of them at VMworld and VMUG events and look forward to more interactions with all these brilliant thinkers and communicators.
Congrats to all the excellent information sharers out there. You have all earned it.
On my side I am super ecstatic that I had 20 people vote for me. Thank you to all the readers of this blog.


--- layout: default title: Item Not Found ---
Please check that you have the right URL, or to go the Homepage. If all else fails, please contact me.


--- layout: post title: Post-Agilism anyone? tags: - Software Development - Work Practices status: publish type: post published: true meta: _edit_last: '451289' --- Agile software development - Wikipedia, the free encyclopedia
Some commentators propose a model of post-Agilism that is effectively constructive anarchy, in that teams should be self-organising to the point where even the core values of the Agile movement are considered too presciptive, and that teams should simply "do whatever works for them".Does this seem a little scary to you? Gives me the heebie jeebies. For those folks who are not familiar with Agile methods I have to say that I am firmly of the opinion that professional Agile developers are in fact some of the most process centric individuals on the planet. It's one of the reasons I like the approach. This process (and we are talking about process in the small) leads to a) greater predictability and b) a mind more able to concentrate on the creative aspects of the job. Post-agilsm seems to the antithiis of this. However a brief paragraph in WikiPedia does not a methodology make so I'm open to discussion.


Alpha Recommendation
Tier S: The S tier represents books within the range of [95 ≤ S ≤ 100]%
Tier A: The A tier represents books within the range of [85 ≤ A < 95]%
Tier B: The B tier represents books within the range of [60 ≤ B < 85]%
Tier C: The C tier represents books within the range of [0 ≤ C < 60]%


All Tycho documentation is on-line.
Most windows have a Help menu at the upper right.
The most useful item in that menu in the long run is the
Concept Index
,
which accesses the documentation via keyword search.
It opens an index browser.
The Help button in the index browser explains how to use it.
In brief, Tab
completes partial entries, if possible. Repeated
Tab
s scroll through multiple matches.
Pattern searches and wildcards are also supported in the browser.
Many Tycho menu commands are available through keyboard shortcuts
so that you do not need to interrupt your typing to use the mouse.
If you find the keyboard shortcuts unfamiliar, you will want to study the
bindings documentation soon.
The items in the help menu and their usefulness
are explained below:
About Tycho
- This opens the Tycho welcome window, which has a hyperlink to the
top level of the Tycho documentation. This provides a convenient
starting point for new users. You should scan the available
documentation to get a feel for what is there.
Tycho Home Page
- The main entry point into the documentation.
Guide to ...
- This points to the documentation for whatever widget belongs to
the help menu. For example, the HTML viewer will have the menu
command
Guide to the ::tycho::HTML widget
. All Tycho widget
names begin with ::tycho::
, which designates the namespace for
Tycho code.
Concept Index
- This opens an index browser for the master index to Tycho documentation.
This is the most useful item in this menu for regular users.
Code Index
- This opens an index browser that accesses the Tycho source code.
This is useful to code developers using Tycho for its primary
purpose: as infrastructure for application development.
The index points to the documentation (which is automatically
generated from comments in the source code) for all classes,
methods, and procedures.
Itcl Man pages
- This opens the Itcl man pages. Itcl2.2 includes HTML format manpages
in
itcl2.2/html
. This Help
menu choice merely
opens up
$TYCHO/itclhtml/TclTkMainList.html
.
The Tycho installer should make links to their local Itcl man pages.
Style Preferences
- This is not really a
Help
item. It opens the Tycho
preference manager, which permits users to customize the appearance of
Tycho.
Class Diagram
- This opens a pictorial representation of the classes that make
up the Tycho system, arranged according to their inheritance
hierarchy. The nodes in the diagram are hyperlinks to the
documentation for the classes. The source code for the classes
can also be accessed using the pop-up menu (usually invoked by the
right mouse button).
Copyright © 1996-1998, The Regents of the University of California.
All rights reserved.
Last updated: 06/07/98,
comments to: tycho@eecs.berkeley.edu


{% include anchor.html edit="true" title="Replicate a database" hash="replication" %}
{% highlight js %}
PouchDB.replicate(source, target, [options])
{% endhighlight %}
Replicate data from `source` to `target`. Both the `source` and `target` can be a PouchDB instance or a string representing a CouchDB database URL or the name of a local PouchDB database. If `options.live` is `true`, then this will track future changes and also replicate them automatically. This method returns an object with the method `cancel()`, which you call if you want to cancel live replication.
Replication is an [event emitter][] like [changes()](#changes) and emits the `'complete'`, `'active'`, `'paused'`, `'change'`, `'denied'`, `'error'` and `'checkpoint'` events.
### Options
All options default to `false` unless otherwise specified.
* `options.live`: If `true`, starts subscribing to future changes in the `source` database and continue replicating them.
* `options.retry`: If `true` will attempt to retry replications in the case of failure (due to being offline), using a backoff algorithm that retries at longer and longer intervals until a connection is re-established, with a maximum delay of 10 minutes. Only applicable if `options.live` is also `true`.
**Filtering Options:**
* `options.filter`: Reference a filter function from a design document to selectively get updates. To use a view function, pass `_view` here and provide a reference to the view function in `options.view`. See [filtered replication](#filtered-replication) for details.
* `options.doc_ids`: Only show changes for docs with these ids (array of strings).
* `options.query_params`: Object containing properties that are passed to the filter function, e.g. `{"foo":"bar"}`, where `"bar"` will be available in the filter function as `params.query.foo`. To access the `params`, define your filter function like `function (doc, params) {/* ... */}`.
* `options.view`: Specify a view function (e.g. `'design_doc_name/view_name'` or `'view_name'` as shorthand for `'view_name/view_name'`) to act as a filter. Documents counted as "passed" for a view filter if a map function emits at least one record for them. **Note**: `options.filter` must be set to `'_view'` for this option to work.
* `options.selector`: Filter using a query/pouchdb-find [selector](http://docs.couchdb.org/en/2.0.0/api/database/find.html#selector-syntax). **Note**: Selectors are not supported in CouchDB 1.x.
**Advanced Options:**
* `options.since`: Replicate changes after the given sequence number.
* `options.heartbeat`: Configure the heartbeat supported by CouchDB which keeps the change connection alive.
* `options.timeout`: Request timeout (in milliseconds).
* `options.batch_size`: Number of change feed items to process at a time. Defaults to 100. This affects the number of docs and attachments held in memory and the number sent at a time to the target server. You may need to adjust downward if targeting devices with low amounts of memory (e.g. phones) or if the documents and/or attachments are large in size or if there are many conflicted revisions. If your documents are small in size, then increasing this number will probably speed replication up.
* `options.batches_limit`: Number of batches to process at a time. Defaults to 10. This (along wtih `batch_size`) controls how many docs are kept in memory at a time, so the maximum docs in memory at once would equal `batch_size` × `batches_limit`.
* `options.back_off_function`: backoff function to be used in `retry` replication. This is a function that takes the current backoff as input (or 0 the first time) and returns a new backoff in milliseconds. You can use this to tweak when and how replication will try to reconnect to a remote database when the user goes offline. Defaults to a function that chooses a random backoff between 0 and 2 seconds and doubles every time it fails to connect. The default delay will never exceed 10 minutes. (See [Customizing retry replication](#customizing-retry-replication) below.)
* `options.checkpoint`: Can be used if you want to disable checkpoints on the source, target, or both. Setting this option to `false` will prevent writing checkpoints on both source and target. Setting it to `source` will only write checkpoints on the source. Setting it to `target` will only write checkpoints on the target.
* `options.style`: Specifies whether all revisions of a document including conflicts and deleted former conflicts (`all_docs`) or only the winning revision (`main_only`) should be replicated. This option is passed to the `changes` endpoint of the replication source. Defaults to `all_docs`.
#### Example Usage:
{% highlight js %}
var rep = PouchDB.replicate('mydb', 'http://localhost:5984/mydb', {
live: true,
retry: true
}).on('change', function (info) {
// handle change
}).on('paused', function (err) {
// replication paused (e.g. replication up to date, user went offline)
}).on('active', function () {
// replicate resumed (e.g. new changes replicating, user went back online)
}).on('denied', function (err) {
// a document failed to replicate (e.g. due to permissions)
}).on('complete', function (info) {
// handle complete
}).on('error', function (err) {
// handle error
});
rep.cancel(); // whenever you want to cancel
{% endhighlight %}
There are also shorthands for replication given existing PouchDB objects. These behave the same as `PouchDB.replicate()`:
{% highlight js %}
db.replicate.to(remoteDB, [options]);
// or
db.replicate.from(remoteDB, [options]);
{% endhighlight %}
The `remoteDB` can either be a string or a `PouchDB` object. If you have a fetch override on a remote database, you will want to use `PouchDB` objects instead of strings, so that the options are used.
#### Replication events
* __`change`__ (`info`) - This event fires when the replication has written a new document. `info` will contain details about the change. `info.docs` will contain the docs involved in that change. See below for an example response.
* __`complete`__ (`info`) - This event fires when replication is completed or cancelled. In a live replication, only cancelling the replication should trigger this event. `info` will contain details about the replication. See below for an example response.
* __`paused`__ (`err`) - This event fires when the replication is paused, either because a live replication is waiting for changes, or replication has temporarily failed, with `err`, and is attempting to resume.
* __`active`__ - This event fires when the replication starts actively processing changes; e.g. when it recovers from an error or new changes are available.
* __`denied`__ (`err`) - This event fires if a document failed to replicate due to validation or authorization errors.
* __`error`__ (`err`) - This event is fired when the replication is stopped due to an unrecoverable failure. If `retry` is `false`, this will also fire when the user goes offline or another network error occurs (so you can handle retries yourself, if you want).
* __`checkpoint`__ - This event exposes information about the internal steps of the replication process. It includes one of the fields `pending_batch`, `start_next_batch`, `revs_diff` or `checkpoint`.
#### Single-shot
As with [changes()](#changes), you can also omit `live`, in which case you can use `replicate()` in the callback/promise style and it will be treated as a single-shot operation.
{% include code/start.html id="replication1" type="callback" %}
{% highlight js %}
db.replicate.to(remote, function (err, result) {
if (err) { return console.log(err); }
// handle 'completed' result
});
{% endhighlight %}
{% include code/end.html %}
{% include code/start.html id="replication1" type="async" %}
{% highlight js %}
try {
var result = await db.replicate.to(remote);
} catch (err) {
console.log(err);
}
{% endhighlight %}
{% include code/end.html %}
{% include code/start.html id="replication1" type="promise" %}
{% highlight js %}
db.replicate.to(remote).then(function (result) {
// handle 'completed' result
}).catch(function (err) {
console.log(err);
});
{% endhighlight %}
{% include code/end.html %}
For non-live replications, the returned object is also an event emitter as well as a promise, and you can use all the events described above (except for `'paused'` and `'active'`, which only apply to `retry` replications).
#### Example Response:
Example response in the `'change'` listener:
{% highlight js %}
{
"doc_write_failures": 0,
"docs_read": 1,
"docs_written": 1,
"errors": [],
"last_seq": 1,
"ok": true,
"start_time": "Fri May 16 2014 18:23:12 GMT-0700 (PDT)",
"docs": [
{ _id: 'docId',
_rev: '1-e798a1a7eb4247b399dbfec84ca699d4',
and: 'data' }
]
}
{% endhighlight %}
Example response in the `'complete'` listener:
{% highlight js %}
{
"doc_write_failures": 0,
"docs_read": 2,
"docs_written": 2,
"end_time": "Fri May 16 2014 18:26:00 GMT-0700 (PDT)",
"errors": [],
"last_seq": 2,
"ok": true,
"start_time": "Fri May 16 2014 18:26:00 GMT-0700 (PDT)",
"status": "complete"
}
{% endhighlight %}
Note that replication is supported for both local and remote databases. So you can replicate from local to local or from remote to remote.
However, if you replicate from remote to remote, then the changes will flow through PouchDB. If you want to trigger a server-initiated replication, please use regular ajax to POST to the CouchDB `_replicate` endpoint, as described [in the CouchDB docs](https://docs.couchdb.org/en/stable/api/server/common.html#api-server-replicate).
#### Filtered replication
As with [changes()](#changes), you can filter from the source database using:
* an ad-hoc `filter` function
* an array of `doc_ids`
* a `filter` function inside of a design document
* a `filter` function inside of a design document, with `query_params`
* a `view` function inside of a design document
If you are replicating from a remote CouchDB, then the first method will run client-side, whereas the last four will filter on the server side. Therefore the last four should be preferred, especially if the database is large, because you want to send as few documents over the wire as possible.
You should also beware trying to use filtered replication to enforce security, e.g. to partition a database per user. A better strategy is the ["one database per user" method](https://github.com/nolanlawson/pouchdb-authentication#couchdb-authentication-recipes).
{% include alert/start.html variant="warning" %}
{% markdown %}
**Deleting filtered docs**: When you use filtered replication, you should avoid using `remove()` to delete documents, because that removes all their fields as well, which means they might not pass the filter function anymore, causing the deleted revision to not be replicated. Instead, set the `doc._deleted` flag to `true` and then use `put()` or `bulkDocs()`.
{% endmarkdown %}
{% include alert/end.html %}
#### Filtering examples
In these examples, we'll work with some mammals. Let's imagine our docs are:
{% highlight js %}
[
{_id: 'a', name: 'Kangaroo', type: 'marsupial'},
{_id: 'b', name: 'Koala', type: 'marsupial'},
{_id: 'c', name: 'Platypus', type: 'monotreme'}
]
{% endhighlight %}
Here are 5 examples using the 5 different systems.
**Example 1: Ad-hoc `filter` function**
*Warning*: this runs client-side, if you are replicating from a remote database.
Filter by `type === 'marsupial'`:
{% highlight js %}
remote.replicate.to(local, {
filter: function (doc) {
return doc.type === 'marsupial';
}
});
{% endhighlight %}
**Example 2: Array of `doc_ids`**
Filter documents with `_id`s `['a', 'c']`.
{% highlight js %}
remote.replicate.to(local, {
doc_ids: ['a', 'c']
});
{% endhighlight %}
**Example 3: `filter` function inside of a design document**
First `put()` a design document in the remote database:
{% highlight js %}
{
_id: '_design/mydesign',
filters: {
myfilter: function (doc) {
return doc.type === 'marsupial';
}.toString()
}
}
{% endhighlight %}
Then filter by `type === 'marsupial'`:
{% highlight js %}
remote.replicate.to(local, {
filter: 'mydesign/myfilter'
});
{% endhighlight %}
**Example 4: `filter` function inside of a design document, with `query_params`**
This is the most powerful way to filter, because it allows you to pass in arbitrary options to your filter function.
First `put()` a design document in the remote database:
{% highlight js %}
{
_id: '_design/mydesign',
filters: {
myfilter: function (doc, req) {
return doc.type === req.query.type;
}.toString()
}
}
{% endhighlight %}
Then filter by `type === 'marsupial'`:
{% highlight js %}
remote.replicate.to(local, {
filter: 'mydesign/myfilter',
query_params: {type: 'marsupial'}
});
{% endhighlight %}
**Example 5: `view` function inside of a design document**
This doesn't really offer any advantages compared to the previous two methods, unless you are already using a `view` for map/reduce queries, and you want to reuse it.
Any documents that `emit()` anything will be considered to have passed this filter method.
First `put()` a design document in the remote database:
{% highlight js %}
{
_id: '_design/mydesign',
views: {
myview: {
map: function(doc) {
if (doc.type === 'marsupial') {
emit(doc._id);
}
}.toString()
}
}
}
{% endhighlight %}
Then filter by `type === 'marsupial'`:
{% highlight js %}
remote.replicate.to(local, {
filter: '_view',
view: 'mydesign/myview'
});
{% endhighlight %}
#### Customizing retry replication
During `retry` replication, you can customize the backoff function that determines how long to wait before reconnecting when the user goes offline.
Here's a simple backoff function that starts at 1000 milliseconds and triples it every time a remote request fails:
{% highlight js %}
db.replicate.to(remote, {
live: true,
retry: true,
back_off_function: function (delay) {
if (delay === 0) {
return 1000;
}
return delay * 3;
}
});
{% endhighlight %}
The first time a request fails, this function will receive 0 as input. The next time it fails, 1000 will be passed in, then 3000, then 9000, etc. When the user comes back online, the `delay` goes back to 0.
By default, PouchDB uses a backoff function that chooses a random starting number between 0 and 2000 milliseconds and will roughly double every time, with some randomness to prevent client requests from occurring simultaneously.


[gecode-users] Optimization
Christian Schulte
cschulte at kth.se
Thu Feb 4 10:19:29 CET 2010
Hi Peter,
Hmm. Why are you so sure that the energy constraint only works if all
variables are already assigned? Don't think about a double as result but try
to think (just for the sake of argument) to express the result of the energy
function as an integer (with some approximation). Then it would be a
constraint between the problem variables and the variable for the energy.
The thing from which search can benefit is just the opposite case: you put a
constraint on the energy variable (derived from a solution found earlier by
search) and there is propagation that narrows down the potential values for
your problem variables.
Waiting for all the problem variables until they become assigned, then (as I
tried to express before) normal search will do as branch and bound search
offers no advantage. Even implementing a propagator that waits until all
variables become assigned and then computes an energy value would not help.
All of this is equivalent to:
- find a first solution and compute its energy value
- keep finding all solutions and discard the worse ones and update to
the better ones
And this, of course, is not really feasible for most problems!
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Peter Vanhee
Sent: Wednesday, February 03, 2010 4:56 PM
To: Christian Schulte
Cc: users at gecode.org
Subject: Re: [gecode-users] Optimization
Thanks for the answer. Conceptually, I see a problem in the energy
constraint:
it can only work if all variables are instantiated. Would it make sense to
write
a function that posts the energy constraint? Something like
void energy(Home home, const IntVarArgs& x, double n, IntConLevel
icl=ICL_DEF);
that would then implement a propagator that will get called once all
variables
are instantiated, checks if the energy is better than n, and if not, fails
the space.
I could then probably call this constraint within the constrain() function
and bypass
use of static variables. Still, it wouldn't change the search tree, but this
is
simply because the energy constraint is unable the domains. Is this correct
reasoning? The static variable seemed much easier to implement than
implementing
a post function.
I hadn't given it a thought to convert the double to an int, but would this
make
sense if there is nothing to prune?
Thanks a lot,
Peter
On 3 Feb 2010, at 16:39, Christian Schulte wrote:
> Hi,
>
> The problem with your solution is that you do not use branch and bound for
> search (as you basically say yourself): what you will do is basically find
> all solutions and pick a best one among them (provided I really understand
> what you are doing). The idea of branch and bound is to add a constraint
> after a solution has been found such that the additional constraint will
> guarantee that a better solution is found next and - crucially! - the
added
> constraint can prune the search space by triggering additional
propagation.
>
> Moreover, your idea is not compatible with parallel search (static
> variable).
>
> Did you think about turning your double value into a sufficiently accurate
> integer variable?
>
> Christian
>
> --
> Christian Schulte, www.ict.kth.se/~cschulte/
>
>
> -----Original Message-----
> From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
> Of Peter Vanhee
> Sent: Wednesday, February 03, 2010 4:30 PM
> To: users at gecode.org
> Subject: [gecode-users] Optimization
>
> Hi all,
>
> I am working on an optimization problem defined using constraints,
> to compute the lowest energy model of a protein lattice. My variables are
> implemented as integer variables that refer to a pool of protein
fragments,
> and I wish to implement an optimization function that - given an
assignment
> of all variables - returns an energy value (double) that should be
> minimized.
>
> So far, I've implemented the optimization as follows:
>
> - in the model constructor, I use synchronized execution to call a
function
> c when all variables become assigned (using wait(Space&, IntVarArray&, c&)
>
> - a static variable that holds the best energy so far
>
> static BEST_ENERGY = 10000;
>
> - the continuation function c looks something like
>
> static void c(Space& _home) {
> // compute energy using assigned variables
> double energy = ...;
>
> if(energy > BEST_ENERGY) {
> // fail if energy is worse
> home.fail();
> } else {
> BEST_ENERGY = energy;
> }
> }
>
>
> This works fine, and I can use different search algorithms to traverse the
> tree
> and move into the direction of lowest energy. However, I am not sure if
this
> is the
> correct way. Initially, I thought about implementing the cost() function
but
> quickly
> discarded it because it only seems to work with integer variables. Also
> using the
> constrain function I need to use a static variable as well, and I don't
know
> what
> kind of constrained I should post there (the energy function can not prune
> domains,
> it can either accept it as better or fail the space..)
>
> Thanks for the clarification!
> Peter
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


This is an skeleton web app, using the Servlet 3.1 specification.
Tools used:
- JDK 7.0: javac, java, javadoc
- Servlet Spec 3.1 (May 2013)
- Tomcat 8.0
- JSP 2.3
- EL 3.1 (expression language ${blah}, etc., part of JSP)
- JSTL 1.2 taglibs (c, fmt, fn).
This jar is not included in Tomcat, so it's placed in this app's lib directory.
It works on Servlet 2.4+.
(Some might choose to put this jar in a shared folder in the server, to make it visible to all apps.
Careful: that will work only in the absence of a version conflict between apps.)
This jar is needed only at runtime, so you should not add it to the project's classpath.
- UTF-8 encoding: all content is encoded as UTF-8, including Java files.
- JDK logging
To do:
- add an optional title param to the head tag
- add a tag for navigation back home, and also an H2 with the app name in it, at the top
- SqlFileReader class; similar: map this+name to a jsp
- form: list N objects; delete one at a time
- form: add an item; parse into a model object; store the model in a dao
- form: edit an existing object from the database, and save the changes
- file upload: post, save to somehere? output the size, type, name. add 'multipart-config' to the web.xml.
There are actually two defined APIs defined in 3.2, a good way (Collection of Parts) and a bad way (InputStream).
Part has mime-type, headers, and an InputStream. Content-disposition='form-data' means its regular form data, not a file.
So, you can mix form upload controls with regular controls.
- filter example: performance monitor
- init-param?
- the running app should link to its own javadoc, with source code links
- a bit of javascript?
- Ant, build.xml for basic scripting needs
- app-reload, app-stop-start, app-redepoly, server-restart
- Tomcat config: reloadable, hot swap, watched resources, jrebel
- login with persistence of the session
- url treatment, forward-redirect
- session survival, and serializable objects
- review the spec for 3.1 and 3.0; File Uploading, async servlets (perf opt), programmatic login/logout.
- annotations: does the web.xml override the code? its a merge of sorts.
- annotations: slower startup, needs to scan 'web.app.metadata-complete' setting in web.xml.
- annotations: "The order can be specified in the deployment descriptor only." [8.1] likely applies to filters too.
- annotations: web.xml overrides.
- Subversion? Why?
- JUnit? To demo that the test can be in the same package as the target
Files specific to Eclipse configuration are also included, as a convenience.
This file is meant to be referenced by the javadoc tool, and incorporated into javadoc output.


This middleware traverses the OWIN pipeline and finds all of the middleware that implements the ISelfDocumenting interface. It calls methods of this interface to gather up all of the documentation for all of the installed middleware and formats in into a big document that provides details of all of the installed components.
The document produced by this middleware is template driven. The default templates are embedded in the assembly, but it looks on disk before using them, so you can override the templates to customize the html and the css and produce the document in whatever format you want.


Showing results for all countries. Data accurate as of . Confirmed Recovered Critical Deaths Reset to All Countries


Getting Started with HTML Notes
John's notes
Components of the web
-
Browser - A Program (example: Mozilla FireFox, Google Chrome, and Inernet Exploiter) that is located on your computer
that is used to display files found on the web.
-
The Internet- The worlds largest computer network.
-
HTTP - Also known as Hyper Text Transfer Protocol. It is one of the main protocols of the web.
-
Servers - host the files that make up the web.
Examples of the files that make up the Web:
- Plain Text
- HTML
- Images
- Video
- Music
HTML Basics:
HTML, Hyper Text Markup Language is comprised of:
- Text content - ie what you see.
- Markup - the construction blocks of html that define what the text looks like.
- References to other documents (Links to video, and images).
- Links to other pages.
Overview of HTML Markup:
HTML is comprised of tags which defines the behavior and appearance of a webpage. Tags are structured as follows:
<name> content </name>.
<name> - is called the opening tag.
contents - is called the tag contents.
</name> - is called the closing tag.
The set of tags is also referred too as an Element. It is important to remember that the behavior of a tag will
remain in effect until it is closed </>!
Example elements found in this exercise
- Will make text bold
- Will make text italic
-   is an anchor tag. An example of this tag in use is in the creation of a link to another webpage.
That tag is constructed with the following syntax:  URL Plain text . In use it would look
something like this: G+ Community Homepage!
-  Will embed an image here.
Note: A closing tag is not needed for this element. It is whats referred to as a Void Tag.
Notes on Whitespace
There are two types of whitespace
- Inline
- Block
Inline Whitespace: Ends a line by wrapping text to a new line.
Examples of inline elements are:
Block Whitespace: Adds an invisible box around the text encapsulated by the tag
Examples of inline elements are:
The Structure of an HTML Document:
The bare bones markup of an html document looks like this...
<!DOCTYPE HTML>

            <title> TITLE </title>

            <content> the content (text, images, links, etc) is contained in the HTML body </content>


EVP_KDF-X963 - The X9.63-2001 EVP_KDF implementation
The EVP_KDF-X963 algorithm implements the key derivation function (X963KDF). X963KDF is used by Cryptographic Message Syntax (CMS) for EC KeyAgreement, to derive a key using input such as a shared secret key and shared info.
"X963KDF" is the name for this implementation; it can be used with the EVP_KDF_fetch() function.
The supported parameters are:
These parameters work as described in "PARAMETERS" in EVP_KDF(3).
The shared secret used for key derivation. This parameter sets the secret.
This parameter specifies an optional value for shared info.
X963KDF is very similar to the SSKDF that uses a digest as the auxiliary function, X963KDF appends the counter to the secret, whereas SSKDF prepends the counter.
A context for X963KDF can be obtained by calling:
EVP_KDF *kdf = EVP_KDF_fetch(NULL, "X963KDF", NULL);
EVP_KDF_CTX *kctx = EVP_KDF_CTX_new(kdf);
The output length of an X963KDF is specified via the keylen parameter to the EVP_KDF_derive(3) function.
This example derives 10 bytes, with the secret key "secret" and sharedinfo value "label":
EVP_KDF *kdf;
EVP_KDF_CTX *kctx;
unsigned char out[10];
OSSL_PARAM params[4], *p = params;
kdf = EVP_KDF_fetch(NULL, "X963KDF", NULL);
kctx = EVP_KDF_CTX_new(kdf);
EVP_KDF_free(kdf);
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
SN_sha256, strlen(SN_sha256));
*p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
"secret", (size_t)6);
*p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO,
"label", (size_t)5);
*p = OSSL_PARAM_construct_end();
if (EVP_KDF_derive(kctx, out, sizeof(out), params) <= 0) {
error("EVP_KDF_derive");
}
EVP_KDF_CTX_free(kctx);
"SEC 1: Elliptic Curve Cryptography"
EVP_KDF(3), EVP_KDF_CTX_new(3), EVP_KDF_CTX_free(3), EVP_KDF_CTX_set_params(3), EVP_KDF_CTX_get_kdf_size(3), EVP_KDF_derive(3), "PARAMETERS" in EVP_KDF(3)
This functionality was added in OpenSSL 3.0.
Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at https://www.openssl.org/source/license.html.


--- layout: post title: ! 'Critique: "Agreement Groups in the United States Senate"' date: 2012-04-07 02:36:56.000000000 +05:30 categories: - Data Visualization Thoughts tags: [] status: publish type: post published: true meta: _edit_last: '1' image: '' quote-author: Unknown quote-url: http:// quote-copy: Unknown audio: http:// link-url: http:// seo_follow: 'false' seo_noindex: 'false' tmac_last_id: '229660833658044416' pvc_views: '967' _jetpack_related_posts_cache: a:1:{s:32:"8f6677c9d6b0f903e98ad32ec61f8deb";a:2:{s:7:"expires";i:1434724371;s:7:"payload";a:3:{i:0;a:1:{s:2:"id";i:1149;}i:1;a:1:{s:2:"id";i:1103;}i:2;a:1:{s:2:"id";i:2580;}}}} author: login: cvlewis email<EMAIL_ADDRESS>display_name: Carl V. Lewis first_name: Carl V. last_name: Lewis excerpt: !ruby/object:Hpricot::Doc options: {} ---
Take a look at this fascinating visualization of U.S. senate agreement groups made by Ph.D. student Adrian Friggeri. Using a complex agreement algorithim based upon data from GovTrack.us, the visualization displays how much all 100 senators of each U.S. Congress during the last 15 years have crossed the aisle –– or stuck to party lines –– on senate-floor votes.
From a design standpoint, the visualization is nearly flawless. The thin red and blue lines help the user form an instant party association, and the light gray bars in the background distinguish each Congress from the next without leading to visual clutter. What's perhaps most impressive is that, despite the fact that the visualization contains far more than 100 different data points, the information is still fairly easy to access and the interface is stil simplistic in feel. Because each Senator's entire individual trajectory is highlighted on mouseover, users can get a glimpse at how willing their respective Senator has been to negotiate a compromise across party lines over the years.
Most of all, the visualization does what all good visualizations should do: tells a story without text. As we can see, the number of Democrats who have crossed the aisle is notably larger than that of their GOP counterparts. This becomes ever more clear when we drill down to look at each party's trajectory individually, where the connections can be seen more clearly. Perhaps what I would've liked to have seen in addition, however, is some sort of summary or average value of the disparity between the two parties on agreement rates, even if just a number at the bottom of the visualization. As it stands, the user has to dissect the visualization a good bit to tell that Democrats have a higher "agreement rate" than Republicans.
The networked line structure reminds me a lot of the Wall Street Journal's "What They Know" visualization, except that this visualization has a good bit less clutter and complexity, and much better styling choices.


UMAP EFDA Metrics
Distance metrics for functions and curves in R^n for use with UMAP (https://github.com/lmcinnes/umap)
moduleauthor:: J. Derek Tucker<EMAIL_ADDRESS>- umap_metric.efda_distance(q1, q2, alpha=0)[source]
” calculates the distances between two curves, where q2 is aligned to q1. In other words calculates the elastic distances/ This metric is set up for use with UMAP or t-sne from scikit-learn
- Parameters:
q1 – vector of size N
q2 – vector of size N
alpha – weight between phase and amplitude (default = 0, returns amplitude)
- Return type:
scalar
- Return dist:
amplitude distance
- umap_metric.efda_distance_curve(beta1, beta2, closed)[source]
” calculates the distances between two curves, where beta2 is aligned to beta1. In other words calculates the elastic distance. This metric is set up for use with UMAP or t-sne from scikit-learn
- Parameters:
beta1 – vector of size n*M
beta2 – vector of size n*M
closed –
if open curves and (1) if closed curves
- Return type:
scalar
- Return dist:
shape distance


Linear handlers can be scoped inline and are very efficient. More...
Functions | |
| void | lh_nothing () |
| ptrdiff_t | _lh_linear_handler_init (const lh_handlerdef *hdef, lh_value local, bool *init) |
| void | _lh_linear_handler_done (ptrdiff_t id, bool init, bool do_release) |
Linear handlers can be scoped inline and are very efficient.
These are used to define implicit parameters, defer, and exceptions.


--- layout: default --- {% include JB/setup %}
OSiRIS is a pilot project funded by the NSF to evaluate a software-defined storage infrastructure for our primary Michigan research universities. OSiRIS will combine a number of innovative concepts to provide a distributed, multi-institutional storage infrastructure that will allow researchers at any of our three campuses to read, write, manage and share their data directly from their computing facility locations.
Our goal is to provide transparent, high-performance access to the same storage infrastructure from well-connected locations on any of our campuses. We intend to enable this via a combination of network discovery, monitoring and management tools and through the creative use of CEPH features.
By providing a single data infrastructure that supports computational access on the data “in-place”, we can meet many of the data-intensive and collaboration challenges faced by our research communities and enable these communities to easily undertake research collaborations beyond the border of their own Universities.
{% for post in paginator.posts %}


Combining registers
You can easily combine data from one register with data from another. This can help if you need access to data from more than one organisation to build your service.
For example, you might need to use data from the country register as well as the territory register to build a feature in your service that users can use to find their location.


magneticalc.Config.Config
class documentationmagneticalc.Config
(View In Hierarchy)
Config class.
| Class Variable | FloatPrecision | Undocumented |
| Class Variable | CoordinatePrecision | Undocumented |
| Class Variable | DebugGetters | Undocumented |
| Class Variable | DefaultWirePreset | Undocumented |
| Class Variable | DefaultPerspectivePreset | Undocumented |
| Class Variable | Default | Undocumented |
| Method | __init__ | Initializes the configuration. |
| Method | set_changed_callback | Sets the callback for any changes to the configuration. |
| Method | get_synced | Returns the synchronization state of the current session. |
| Method | set_filename | Sets the filename for the current session. |
| Method | get_filename | Gets the filename of the current session. |
| Method | load | Loads the configuration from file. |
| Method | set_defaults | Sets the default key-value pairs. Creates empty "User" section if not present. |
| Method | save | Saves the configuration to file. |
| Method | close | Finally auto-saves configuration to file. |
| Method | remove_key | Removes a key from the configuration. |
| Method | get_bool | Gets boolean value, convert from string. |
| Method | get_float | Gets float value, convert from string. |
| Method | get_int | Gets integer value, convert from string. |
| Method | get_points | Gets list of 3D points, convert from string. |
| Method | get_point | Gets a single 3D point, convert from string. |
| Method | get_str | Reads a configuration value. Key must be in "Default" section and may be overridden in "User" section. |
| Method | set_bool | Sets boolean value, convert to string. |
| Method | set_float | Sets float value, convert to string. |
| Method | set_int | Sets integer value, convert to string. |
| Method | set_points | Sets list of 3D points, convert to string. |
| Method | set_point | Sets a single 3D point, convert to string. |
| Method | set_str | Writes a configuration value. Key must be in "Default" section and may be overridden in "User" section. |
| Method | set_get_bool | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Method | set_get_float | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Method | set_get_int | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Method | set_get_points | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Method | set_get_point | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Method | set_get_str | If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value. |
| Static Method | point_to_str | Converts a single 3D point to string. |
| Static Method | points_to_str | Converts list of 3D points to string. |
| Static Method | str_to_point | Converts string to single 3D point. |
| Static Method | str_to_points | Converts string to list of 3D points. |
| Method | get_generic | Gets some "_key"-"_value" of data type "_type". |
| Method | set_generic | Sets some "_key"-"_value" of data type "_type". |
| Method | set_get_dict | If "values" is None, reads and returns all key-values in "types". Note: The actual keys saved in the configuration file are prefixed with "prefix", and suffixed with "suffix". |
| Instance Variable | _config | Undocumented |
| Instance Variable | _synced | Undocumented |
| Instance Variable | _changed_callback | Undocumented |
| Instance Variable | _filename | Undocumented |
Sets the callback for any changes to the configuration.
| Parameters | config_changed_callback | Gets called when the filename or the synchronization flag changed |
Sets the filename for the current session.
| Parameters | filename | Filename |
Sets the default key-value pairs. Creates empty "User" section if not present.
Gets list of 3D points, convert from string.
| Parameters | key | Key |
| Returns | List of 3D points |
Gets a single 3D point, convert from string.
| Parameters | key | Key |
| Returns | Single 3D point |
Reads a configuration value. Key must be in "Default" section and may be overridden in "User" section.
| Parameters | key | Key |
| Returns | Value |
Sets list of 3D points, convert to string.
| Parameters | key | Key |
| value | List of 3D points |
Sets a single 3D point, convert to string.
| Parameters | key | Key |
| value | Single 3D point |
Writes a configuration value. Key must be in "Default" section and may be overridden in "User" section.
| Parameters | key | Key |
| value | Value |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
If value is not None, writes and returns key-value; otherwise (if value is None), reads and returns key-value.
| Parameters | key | Key |
| value | Value or None |
Converts a single 3D point to string.
| Parameters | point | Single 3D point |
| Returns | String |
Converts list of 3D points to string.
| Parameters | points | List of 3D points |
| Returns | String |
Converts string to single 3D point.
| Parameters | str_point | String |
| Returns | Single 3D point |
Converts string to list of 3D points.
| Parameters | str_points | String |
| Returns | List of 3D points |
Gets some "_key"-"_value" of data type "_type".
| Parameters | _key | Key |
| _type | Data type | |
| Returns | Data (type determined by "_type") |
Sets some "_key"-"_value" of data type "_type".
| Parameters | _key | Key |
| _type | Data type | |
| _value | Data (type determined by "_type") |
If "values" is None, reads and returns all key-values in "types". Note: The actual keys saved in the configuration file are prefixed with "prefix", and suffixed with "suffix".
If "values" is not None, writes and returns all key-values in "types". Note: In this case, "values" must have the same keys as "types.
| Parameters | prefix | Prefix |
| suffix | Suffix | |
| types | Key:Type (Dictionary) | |
| values | Key:Value (Dictionary) or None |


| DOSE: T+ 0:00 |
240 mg |
oral |
DXM |
(pill / tablet) |
| T+ 4:00 |
240 mg |
oral |
DXM |
(pill / tablet) |
| T+ 6:30 |
5 hits |
smoked |
Cannabis |
|
It was my third time to take Coricidin – and I don't even want to think of how many times I had smoked weed. Me and my friend took the pills (8) at 10:30 pm that night. We then went to his friend's house till about 12. The effects were taking very long till they kicked in. Finally at about 1:30 they hit us and they hit us very, very hard. It was a normal DXM trip from the start. Weird walking, everything seemed so big and yet so small. I could see the childhood face of my friend on his now grownup body; it was quite humorous. We listened to music for a while and it was a great time. We listened to a lot of Marilyn Manson he's great. We then listened to a Metallica song Low Mans Lyric and commented on how great it was and listened to it over and over again. We then of course talked about life and thought we knew everything and we were so smart.
That's when we popped 8 more pills – at about 2:30 in the morning. Then we really started getting hit hard. I was walking around as if I were being controlled in a Nintendo game and couldn't control my own legs.  At about 4:25 in the morning it began getting light out. We went into his bathroom and spun around and watched each others eyes twitch like crazy – it's so cool to do. We then looked in the mirror and envisioned our childhood selves coming out in demon like forms...at least I did. It was quite weird.
At about 5:00 AM we went out on my friend's porch and smoked this very chronic weed he had purchased. Immediately after the first two hits I began to felt very good about myself. I took 5 HUGE hits and then we went and disposed of the coke bong and sat on the table. My friend Shawn commented, 'This is a new feeling...a totally new feeling.' I began to laugh for no reason feeling so high it felt like all the THC in the world was coating my brain.  I immediately got a water, which only made the dry mouth feel better when it touched my mouth, once it was swallowed the dry mouth was back. I think at about this time my next 8 Coricidin pills hit me, and my friend Shawn said 'We are in Heaven' I looked out over the lake he lives on and I felt raised above everything. I felt as if the environment were fading away from me and I was a king or a ruler of some land.
Then the dry mouth began to feel very unpleasant and I got up and walked and my body was pulsating with an odd energy. Like electricity flowing through my body. By far the worst physical effect any drug has ever given me. I told Shawn he needed to call 911 because at this point I feared for my life when I felt my heart beating extremely fast! He said, 'Jeff, I felt like I was going to die once when I took ecstasy...my friend helped me through it. I will help you get through this Jeff.' Then he started rambling about us being in heaven and how I can't die in Heaven; I'm already dead. This made me very angry because I didn't want to be dead and I thought I was now in Hell and Satan was making it feel like Heaven to torture us.
This is when I told Shawn I seriously needed help and wasn't right at all. I had taken DXM twice before and smoked a lot of weed. This feeling wasn't normal. He then told me to sit down on the chair and I'd feel better soon. He then went to play my favorite song, Low Mans Lyric. and then I floated down to Earth, came back into reality, and came back into a very good normal trip. This is hen I realized that Shawn had saved me from either dying or going insane.
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.


[§304A-3007] Annual report. The research corporation shall submit an annual report to the governor, the president of the senate, and the speaker of the house of representatives. The report shall include but not be limited to the corporation's audited financial statement, total amount of payroll and other disbursements made, and progress and accomplishments made during the year. [L 2006, c 75, pt of §2]
Cross References
Due date of reports, see §93-12.


I'd been using stimulants for over a year before I decided I had a problem. Rather than seeking professional help however, I tried the self help method of taking different pills!
It started out as taking a gravol or two to help me come down when I wanted to sleep, it eventually grew, however, into going out and finding prescriptions to put me to sleep instead!
I went out and I got my first prescription to Zopiclone (or Imovane as it was labeled on the bottle). The little ovoid green pills have 7.5 milligrams of zopiclone each. At just over 15 dollars Canadian for a bottle of twenty, it’s pretty damned cheap too.
Anyways, it was late one night, and I had some sort of engagement the next day (school, possibly work), and I decided that I'd had too much Dexedrine and I needed to sleep. I reached for the bottle. I took one at first. 30 minutes later, I felt very little effects, just a pleasant Drunkenness on top of my Amphetamine high. I then went ahead and took another one.
I laid down in my bed with the lights off and tried to sleep, but to no avail. 30 minutes after taking the second one, I started to hallucinate. I thought to myself ‘Oh, great, a flashback, just what I need when I’m trying to sleep'.
I decided to get up and use the washroom, maybe have some tea or something. Walking was not overly difficult, but still pretty tricky.
I reached the bathroom after what seemed like an eternity (actually only about 12 steps), and things began to seem like they had water coming out of them, not in a frightening way, it was actually rather pleasant. The flooring looked like it was on an old computer with 256 color resolution with major gamut problems, and on top of that, it appeared to be liquid as well.
I finished in the bathroom and headed to the kitchen,two flights of stairs later I reached the kettle and turned it on.
Things seemed to really start to go crazy at this point, everything looked like it had a steam like texture, almost melty, but not quite. After I finished my tea (licorice spice, my personal favorite), I headed up to my room, and more or less passed out.
That was only the first time.
Other times I had done this intentionally and it was much more enjoyable.
One of the times there was a painting of a tree hanging in my ex-girlfriends grandmothers house, it looked as though it was turning away, running even, it was crying... I refused to believe that the painting wasn’t actually a canvas mould of something, but it was a two dimensional image.
Another time I was walking home...
I thought I’d seen an experimental fighter jet, the northern lights, AND a meteor shower, all in one go.
I had a rather nasty experience with this combonation.
After an entire night of being awake and watching colors change, things spin, and shadows move about, I began to think there was something in my mattress.
At first I thought it was just bugs of some sort, no big deal, take the sheets off, mattress goes outside for a while.
The hallucination escalated to mice, to some sort of small primate...
Either way, it resulted in my cutting open my mattress, spraying a fire extinguisher in, using up an entire can of raid, and wasting paint thinner to kill non-existent things I had removed from the mattress.
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.


A simple and the early stage package for matrix profile based on the paper of Chin-Chia Michael Yeh, Yan Zhu, Liudmila Ulanova, Nurjahan Begum, Yifei Ding, Hoang Anh Dau, Diego Furtado Silva, Abdullah Mueen, and Eamonn Keogh (2016) <doi:10.1109/ICDM.2016.0179>. This package calculates all-pairs-similarity for a given window size for time series data.
| Version: | 0.5.0 |
| Depends: | R (≥ 3.0.0), graphics, stats, TTR, zoo, fftw, signal |
| Published: | 2018-08-17 |
| Author: | Donghwan Kim |
| Maintainer: | Donghwan Kim <donhkim9714 at korea.ac.kr> |
| License: | GPL-3 |
| URL: | https://github.com/ainsuotain/matrixprofile |
| NeedsCompilation: | no |
| CRAN checks: | matrixProfile results |
| Reference manual: | matrixProfile.pdf |
| Package source: | matrixProfile_0.5.0.tar.gz |
| Windows binaries: | r-devel: matrixProfile_0.5.0.zip, r-release: matrixProfile_0.5.0.zip, r-oldrel: matrixProfile_0.5.0.zip |
| OS X binaries: | r-release: matrixProfile_0.5.0.tgz, r-oldrel: matrixProfile_0.5.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=matrixProfile to link to this page.


Think Folktale should do something it doesn't yet? Read on.
Think Folktale should do something it doesn't yet? Read on.
Folktale doesn't do everything, so more often than not you'll find something that you wish Folktale supported but that isn't implemented yet. Maybe the thought has never crossed our minds. This is a great opportunity to tell us about that feature you want.
Before you open an issue in the GitHub tracker, however, it's important to consider whether the feature you're proposing really belongs in Folktale. Here are a few guidelines for things that would be a good fit for Folktale:
The feature is an algebraic data structure, with well-defined mathematical laws governing its behaviour. Folktale is a functional library greatly inspired by Abstract Algebra and Category Theory, and it avoids law-less functionality where possible in order to make abstractions safer and more composable.
The feature is an utility function that covers a recurrent pattern. Sometimes the abstractions provided in Folktale are general, but still require some boilerplate when doing common things with it. Utility functions that avoid this boilerplate by providing the feature out of the box are a great fit.
If you're in doubt on whether the feature you have in mind fits Folktale or not, open an issue anyway, that way we can start a discussion about it. You can also ask in the Gitter channel.
When you open an issue, it's important to describe clearly what the missing feature is, and why it is important to have this feature. Examples are a great way to present the feature and show how it would look like when implemented.
If you're not sure about how to format it, you can follow this template:
(A short description of what the functionality is)
(An example showing how one would use the functionality)
### Why?
(Describe why the functionality is important to have in Folktale)
### Additional resources
(If there are any materials relevant to the suggestion — a paper, a talk on the
subject, etc. you can provide them here)
Here's an example of a feature request using this template:
I would like to have a `.concat` method for `Data.Validation`.
const v1 = Validation.Failure(1);
const v2 = Validation.Failure("error");
v1.concat(v2)
// => Validation.Failure([1, "error"])
### Why?
Validations can already aggregate failures through the applicative instance, but
this requires lifting all failures into a semigroup (like Array), and
constructing a curried function with N arguments to handle the Success case. So,
while one can achieve the same as the example above by using `.ap`, it requires
much more effort.
We often have to aggregate unrelated failures. Some of these failures might not
have been lifted into a semigroup yet. So we'd like a simpler function that only
provides the failure aggregation part.


Google Photos for Android rolls out ‘Info’ menu redesign with new carousel
by Abner LiFirst spotted in September, Google Photos for Android is now widely rolling out a redesigned bottom sheet menu for viewing image info and taking actions. It replaces the old overflow implementation for a much cleaner and more centralized interface.
The actual screen when viewing a photo is unchanged. However, tapping the overflow button in the top-right corner slides up the Info panel rather than opening a long menu with nine items.
Also accessible by swiping up, there is now a carousel at the top of this bottom sheet with the same actions: Add to album, Move to archive, Delete from device, Order photo, Use as, Slideshow, and Print. Each is accompanied by a descriptive Material Theme icon and large touch target.
The EXIF data that appears below has been slightly tweaked. The day, date, and time is now on one line, with the description field underneath. The “Location” map with coordinates is next. “Details” like file name, size, resolution, and megapixel count — along with device details — is now at the very bottom.
This Google Photos menu redesign is more widely rolling out — compared to September — with version 4.30 of the Android app from the Play Store this afternoon. There were some reports of it hitting devices running 4.29 over the weekend, thus suggesting this is a server-side introduction. It’s already available on iOS, and live on several devices we checked after updating today.
More about Google Photos:
- Google Photos for Android rolling out sorting in Albums tab
- Pixel 4 can ‘Export frames’ from recorded video with new Google Photos editor UI
- This is Google Photos’ black-and-white ‘Colorize’ filter in action [Gallery]
FTC: We use income earning auto affiliate links. More.


AVR Libc Home Page
AVR Libc Development Pages
Main Page
User Manual
Library Reference
FAQ
Alphabetical Index
Example Projects
Related Pages
Here is a list of all related documentation pages:
Toolchain Overview
Memory Areas and Using malloc()
Memory Sections
Data in Program Space
avr-libc and assembler programs
Inline Assembler Cookbook
How to Build a Library
Benchmarks
Porting From IAR to AVR GCC
Frequently Asked Questions
Building and Installing the GNU Tool Chain
Using the GNU tools
Using the avrdude program
Release Numbering and Methodology
Acknowledgments
Todo List
Deprecated List
Automatically generated by Doxygen 1.5.6 on 4 Dec 2008.


bent_plume_model.Particle¶
| Release: | 1.1 |
|---|---|
| Date: | Nov 08, 2017 |
-
class
bent_plume_model.
Particle
(x, y, z, dbm_particle, m0, T0, nb0, lambda_1, P, Sa, Ta, K=1.0, K_T=1.0, fdis=1e-06, t_hyd=0.0)[source][source]¶ Special model properties for tracking inside a Lagrangian plume object
This new
Particle
class is needed to allow dispersed phase particles to be tracked within the Lagrangian plume element during the solution and to exit the plume at the right time.This object inherits the
dispersed_phases.PlumeParticle
object and adds functionality for three-dimensional positioning and particle tracking. All behavior not associated with tracking is identical to that in thedispersed_phases.PlumeParticle
object. Moreover, this object can be used in astratified_plume_model.Model
simulation.Parameters: x : float
Initial position of the particle in the x-direction (m)
y : float
Initial position of the particle in the y-direction (m)
z : float
Initial position of the particle in the z-direction (m)
dbm_particle :
dbm.FluidParticle
ordbm.InsolubleParticle
objectObject describing the particle properties and behavior
m0 : ndarray
Initial masses of one particle for the components of the dbm_particle object (kg)
T0 : float
Initial temperature of the of
dbm
particle object (K)nb0 : float
Initial number flux of particles at the release (#/s)
lambda_1 : float
spreading rate of the dispersed phase in a plume (–)
P : float
Local pressure (Pa)
Sa : float
Local salinity surrounding the particle (psu)
Ta : float
Local temperature surrounding the particle (K)
K : float, default = 1.
Mass transfer reduction factor (–).
K_T : float, default = 1.
Heat transfer reduction factor (–).
fdis : float, default = 1.e-6
Fraction (–) of the initial mass of each component of the mixture when that component should be considered totally dissolved.
Attributes
particle ( dbm.FluidParticle
ordbm.InsolubleParticle
object) Stores the dbm_particle object passed to at creation.composition (str list) Copy of the composition attribute of the dbm_particle object. m0 (ndarray) Initial masses (kg) of one particle for the particle components T0 (float) Initial temperature (K) of the particle cp (float) Heat capacity at constant pressure (J/(kg K)) of the particle. K (float) Mass transfer reduction factor (–) K_T (float) Heat transfer reduction factor (–) fdis (float) Fraction of initial mass remaining as total dissolution (–) diss_indices (ndarray bool) Indices of m0 that are non-zero. t_hyd (float) Formation time for a hydrate skin (s) nb0 (float) Initial number flux of particles at the release (#/s) nbe (float) Number of particles associated with a Lagrangian element (#). This number with the mass per particle sets the total mass of particles inside the Lagrangian element at any given time. This value is set by lmp.bent_plume_ic
.lambda_1 (float) Spreading rate of the dispersed phase in a plume (–) m (ndarray) Masses of the particle components for a single particle (kg) us (float) Slip velocity (m/s) rho_p (float) Particle density (kg/m^3) A (float) Particle surface area (m^2) Cs (ndarray) Solubility of each dissolving component in the particle (kg/m^3) beta (ndarray) Mass transfer coefficients (m/s) beta_T (float) Heat transfer coefficient (m/s) T (float) Temperature of the particle (K) integrate (bool) Flag indicating whether or not the particle is still inside the plume, where its trajectory should continue to be integrated. t (float) Current time since the particle was released (s) x (float) Current position of the particle in the x-direction (m) y (float) Current position of the particle in the y-direction (m) z (float) Current position of the particle in the z-direction (m) p_fac (float) Buoyant force reduction factor due to a reduced buoyancy as the particle moves to the edge of the plume (–) b_local (float) Width of the bent plume model at the location where the particle exited the plume. sbm ( single_bubble_model.Model
object) Model object for tracking the particle outside the plumeMethods
diameter
(m, T, P, Sa, Ta)Compute the diameter of a particle from mass and density outside
(Ta, Sa, Pa)Remove the effect of particles if they are outside the plume properties
(m, T, P, Sa, Ta, t)Return the particle properties from the discrete bubble model run_sbm
(profile)Run the single_bubble_model
to track particles outside the plumetrack
(t_p, X_cl, X_p, q_local[, Ainv])Track the particle in the Lagragian plume model update
(m, T, P, Sa, Ta, t)Store the instantaneous values of the particle properties Particle.track
(t_p, X_cl, X_p, q_local[, Ainv])Track the particle in the Lagragian plume model


Moments Slider v0.3
Start Slideshow
Select start date and end date
Start Date:
End Date:
Interval:
3 sec
5 sec
10 sec
15 sec
30 sec
<
>
Info


??
?
?
?
?
jo
1
2
3
4
5
6
7
8
9
10
The
New
York
?
???I
cm
copyright
reserved
Botanical
Garden
;
-
.
.
'
Õ
..
NEW
YORK
BOTANICAL
GARDEN
DET
.
BY
M
501045
MILDRED
E.
MATHIAS
Ç*¥
^
THE
NEW
YORK
BOTANICAL
GARDEN
EXPLORATION
OF
CUBA
Province
of
pinar
del
Rio
along
Camino
aguacate
from
Bahia
Honda
to
Ba–os
Aguacate
mo
.fit*
i,
.....
/
(<2?À/vL^la^^.
PERCY
WILSON,
COLLECTOR
DECEMBER
11,
12,
1910
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


miscTools: Miscellaneous Tools and Utilities
Miscellaneous small tools and utilities.
Many of them facilitate the work with matrices,
e.g. inserting rows or columns, creating symmetric matrices,
or checking for semidefiniteness.
Other tools facilitate the work with regression models,
e.g. extracting the standard errors,
obtaining the number of (estimated) parameters,
or calculating R-squared values.
| Version: |
0.6-22 |
| Depends: |
R (≥ 2.14.0) |
| Suggests: |
Ecdat (≥ 0.1-5) |
| Published: |
2016-11-25 |
| Author: |
Arne Henningsen, Ott Toomet |
| Maintainer: |
Arne Henningsen <arne.henningsen at gmail.com> |
| License: |
GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: |
http://www.micEcon.org |
| NeedsCompilation: |
no |
| Materials: |
NEWS |
| CRAN checks: |
miscTools results |
Downloads:
Reverse dependencies:
| Reverse depends: |
bgsmtr, CNLTreg, FRESA.CAD, intReg, IQCC, lmmlasso, maxLik, polywog |
| Reverse imports: |
censReg, DIFlasso, EffectStars2, fastR2, frontier, LOST, MAINT.Data, micEcon, micEconAids, micEconCES, micEconIndex, micEconSNQP, mvProbit, sampleSelection, SimTimeVar, yhat |
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=miscTools
to link to this page.