Fundamentals of Ecology (BIO/ESS 148) :: Syllabus, Summer 2023
< Back to Course Page
> To Course Schedule
- Lecture Time: Tuesday and Thursdays, 8:30-11:15pm
- Lecture Location: Remote and synchronous on Zoom
- Discussion section time
- Instructor: Justin D. Yeakel; Office Hours: TBD
- Teaching Assistant: Lisa Paggeot; Office Hours: TBD
- Course Websites
Everything that we do this this course will revolve around two principle websites. In some cases, information will be duplicated on both sites (link to readings), and I will attempt to cross-link as necessary.The CatCourse Website (Canvas): Turning in assignments, grades, lectures, links to readings
The Ecology Course Website: Basic course information, discussion section activities, links to readings -
Course Schedule:
-
Course Description
This course fulfills an upper division requirement for the Ecology and Evolutionary Biology (EEB) emphasis track of the Biological Sciences Major, as well an upper division requirement for the Earth Systems Science Major. This course provides an introduction to ecology - the scientific study of how organisms interact with each other and their physical environment. Prerequisite: BIO 001 or BIO 005 or ESS 001 or ESS 005 or consent of instructor. Normal Letter Grade only.
- Course Goals & Outcomes
- Goals
- Learn key concepts and major topics in ecology, including: how organisms interact with their environment; the dynamics and regulation of populations; the various types and character of the interactions among organisms; the nature, geography, and biodiversity of communities; the structure and function of ecosystems; and applied and large-scale ecological topics, such as conservation biology, landscape ecology and ecosystem management, and global change
- Understand the linkages between ecology and the other subfields of the biological sciences and earth systems science
- Understand the fundamentals of the methods used in ecological research
- Appreciation for the positive and negative impacts of humans on ecological systems
- Be able to communicate ecological knowledge to other scientists and laypersons, and apply basic concepts to comprehend and evaluate science in the popular press and in the primary scientific literature
- Outcomes At the end of the course, students should be able to:
- Explain the fundamental ecological principles that pertain to individual organisms, to populations, to communities, to ecosystems, to landscapes, and to the globe
- Develop a broad appreciation of the linkages among ecology, evolution, and earth systems science
- Describe and understand the various techniques used in ecology, from computation to experimental, and how these techniques are coupled with the scientific method to address ecological questions
- Comprehend the practical applications of ecological principles in human society and the potential impacts of humans on ecological systems
- Critically evaluate the scientific literature as well as the popular press, and take ownership of the course material to improve their functioning in society
- Goals
-
Format & Procedures
This course is structured as follows: two 165-minute lecture sessions and one 110-minute discussion section per week. Discussion sections will provide students an opportunity to discuss in more detail scientific findings from peer-reviewed publications and practice using the R programming langauge to confront ecological problems. Your participation in lectures and discussion sections is mandatory.
- Course Requirements & Grading Procedures
- Class Attendance and Participation Policy
- This course is delivered synchronously over ZOOM The lecture & discussion attendance at the time of the lecture & discussion is required.
- Attendance and participation in the discussion section is required and will be a component of the student’s course grade.
- The 2 lowest lecture attendance scores will be dropped
- Required and Supplemental Readings
- Required Textbook: W.D. Bowman, S.D. Hacker, and Cain, M.L. 2017. Ecology, 4th or 5th Edition. Sinauer Associates, Inc., Publishers. Sunderland, MA.
- There is a Follett Discover link - I’m having trouble getting word on its activation with our class… if you have difficulties accessing the book through the Follett Discover link, search for Ecology via the campus bookstore website.
- Readings will also be assigned for the Discussion section and instead of the book for some lectures. These are required and will be provided on the course website.
- Note: earlier editions (1st, 2nd, 3rd) of this textbook may be used but are not recommended.
- In-class laptops or tablets
- Each student will be expected to have access to a laptop or tablet during lectures and discussion sections to explore ecological models. Any operating system will suffice, as will iPads or similar tablet-like devices. Smartphones are not recommended.
- Course Assignments and Projects
- Homework: Throughout the semester, homework assignments will be assigned, consisting of exercises provided by the Teaching Assistant/Instructor. Homework assignments will be delivered via Canvas
- Discussion Activities: All students are required to go to their respective Discussion Sections and participate/engage in the discussions and activities conducted in the section. Your discussion grade will take into account both participation and responses to Discussion assignments. Only otherwise notified, Discussion Activity scores will be delivered via CatCourses
- Exams: There will be 2 “midterm” exams during the semester and 1 comprehensive final. There will be no make-up exams or early exams. If you are sick during an exam, you must supply a note from your doctor verifying your illness. Your grade for the missed exam will be based on your average score from the other exams. You cannot miss more than one exam for an excused illness and taking the final is mandatory in order to pass the course. Exams may either be in person or delivered remotely via Canvas, as the situation requires
- Grading: Your final grade will be based on the following: lecture attendance: 10%; discussion section participation & activities: 20%; homework: 20%; midterms: 30% (two, 15% each); and comprehensive final exam: 20%.
- Grades will be given using the approximate framework: A: 90 - 100%, B: 80 - 90%, C: 70 - 80%, D: 60 - 70%, F: < 60%. This framework is subject to change given the distribution of the final grades.
- Late assignments (e.g., homework) will not be accepted.
- Homework: Throughout the semester, homework assignments will be assigned, consisting of exercises provided by the Teaching Assistant/Instructor. Homework assignments will be delivered via Canvas
- Class Attendance and Participation Policy


public class HttpClient
extends java.lang.Object
connectionUrl
property
and then simply add some methods that would be used to contact some different sub-urls with the same url base. Those
methods may receive some parameters that would enable to build final url based on pre-set base url. However this
class may be used on its own as well. All you will need to do is to set a value for content type using method
setContentType(String)
if needed, or/and any other request header using method
setRequestHeader(String, String)
and then just call method sendHttpRequest(String, HttpMethod)
or sendHttpRequest(String, HttpMethod, String)
(or if the reply is expected to be binary such as image then
call the methods sendHttpRequestForBinaryResponse(String, HttpMethod)
or
sendHttpRequestForBinaryResponse(String, HttpMethod, String)
)| Modifier and Type | Class and Description |
|---|---|
static class |
HttpClient.HttpMethod |
| Constructor and Description |
|---|
HttpClient() |
| Modifier and Type | Method and Description |
|---|---|
void |
clearAllRequestProperties()
This method clears all request properties.
|
java.lang.String |
getConnectionUrl()
This method is a getter for connectionUrl property which only makes sense if that property was set.
|
TimeInterval |
getConnectTimeout()
This method returns connection timeout currently in effect.
|
java.lang.String |
getContentType()
This is getter method for content type property.
|
protected java.lang.String |
getDefaultContentType()
This method is intended to be overridden by extending classes if those classes provide methods that send
requests with the same content type
|
int |
getLastResponseCode()
This method returns the status code from the last HTTP response message.
|
java.util.List<java.lang.String> |
getLastResponseHeader(java.lang.String fieldName)
This method returns the values of the header field by field name from last executed http request as unmodifiable list.
|
java.util.Set<java.lang.String> |
getLastResponseHeaderNames()
This method returns header fields names from last executed http request as unmodifiable set.
|
java.util.Map<java.lang.String,java.util.List<java.lang.String>> |
getLastResponseHeaders()
This method returns header fields from last executed http request as unmodifiable map.
|
java.lang.String |
getLastResponseMessage()
This method returns the last HTTP response message.
|
TimeInterval |
getReadTimeout()
This method returns read timeout currently in effect.
|
protected java.net.HttpURLConnection |
openHttpUrlConnection(java.lang.String url,
HttpClient.HttpMethod method)
This method creates and opens
HttpURLConnection to specified URL The connection's property
doOutput is set to false |
protected java.net.HttpURLConnection |
openHttpUrlConnection(java.lang.String url,
HttpClient.HttpMethod method,
boolean doOutput)
This method creates and opens
HttpURLConnection to specified URL. |
java.lang.String |
removeRequestProperty(java.lang.String propertyName)
This method removes request property
|
java.lang.String |
sendHttpRequest(HttpClient.HttpMethod callMethod)
This method sends HTTP request to pre-set URL.
|
java.lang.String |
sendHttpRequest(HttpClient.HttpMethod callMethod,
java.lang.String data)
This method sends HTTP request to pre-set URL.
|
java.lang.String |
sendHttpRequest(java.lang.String requestUrl,
HttpClient.HttpMethod callMethod)
This method sends HTTP request to specified URL and uses specified HTTP method.
|
java.lang.String |
sendHttpRequest(java.lang.String requestUrl,
HttpClient.HttpMethod callMethod,
java.lang.String data)
This method sends HTTP request to specified URL, uses specified HTTP method and sends data through request body.
|
java.nio.ByteBuffer |
sendHttpRequestForBinaryResponse(HttpClient.HttpMethod callMethod)
This method sends HTTP request to pre-set URL.
|
java.nio.ByteBuffer |
sendHttpRequestForBinaryResponse(HttpClient.HttpMethod callMethod,
java.lang.String data)
This method sends HTTP request to pre-set URL.
|
java.nio.ByteBuffer |
sendHttpRequestForBinaryResponse(java.lang.String requestUrl,
HttpClient.HttpMethod callMethod)
This method is the same as
sendHttpRequest(String, HttpMethod) except that it returns ByteBuffer
that holds binary info. |
java.nio.ByteBuffer |
sendHttpRequestForBinaryResponse(java.lang.String requestUrl,
HttpClient.HttpMethod callMethod,
java.lang.String data)
This method is the same as
sendHttpRequest(String, HttpMethod, String) except that it returns
ByteBuffer that holds binary info. |
void |
setConnectionUrl(java.lang.String connectionUrl)
Setter for connectionUrl property.
|
void |
setConnectTimeout(long timeValue,
java.util.concurrent.TimeUnit timeUnit)
This is convenience method that allows to set connection timeout from timeValue and TimeUnit parameters that are used
to instantiate
TimeInterval |
void |
setConnectTimeout(java.lang.String timeIntervalStr)
This is convenience method that allows to set connection timeout from a string that is parsed to
TimeInterval . |
void |
setConnectTimeout(TimeInterval connectTimeout)
This method sets the connection timeout that will remain in effect for all subsequent connection requests until it is
changed by invocation of this or other connection timeout setter methods:
setConnectTimeout(String) ,
setConnectTimeout(long, TimeUnit) |
void |
setContentType(java.lang.String contentType)
This is setter method for content type property.
|
void |
setReadTimeout(long timeValue,
java.util.concurrent.TimeUnit timeUnit)
This is convenience method that allows to set read timeout from timeValue and TimeUnit parameters that are used
to instantiate
TimeInterval |
void |
setReadTimeout(java.lang.String timeIntervalStr)
This is convenience method that allows to set read timeout from a string that is parsed to
TimeInterval . |
void |
setReadTimeout(TimeInterval readTimeout)
This method sets the read timeout that will remain in effect for all subsequent connection requests until it is
changed by invocation of this or other read timeout setter methods:
setReadTimeout(String) ,
setReadTimeout(long, TimeUnit) |
void |
setRequestHeader(java.lang.String headerName,
java.lang.String headerValue)
This method is a general request header setter.
|
void |
setRequestProperty(java.lang.String headerName,
java.lang.String headerValue)
Deprecated.
|
public java.lang.String getConnectionUrl()
public void setConnectionUrl(java.lang.String connectionUrl)
connectionUrl
- public java.lang.String sendHttpRequest(HttpClient.HttpMethod callMethod) throws java.io.IOException
getConnectionUrl()
to get the URL and uses
specified HTTP method. Obviously it is expected that user should set connectionUrl property by invoking method
setConnectionUrl(String)
beforehand. It returns response
that is expected to be textual such as a String. This method does not send any info through request body.
It may send parameters through URL. So this method fits perfectly for using HTTP GET method. If HTTP request
uses method POST, PUT or any other methods that allow passing info in the request body and there is some info
to be sent then use method sendHttpRequest(HttpMethod, String)
callMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be usedjava.io.IOException
public java.lang.String sendHttpRequest(java.lang.String requestUrl, HttpClient.HttpMethod callMethod) throws java.io.IOException
sendHttpRequest(String, HttpMethod, String)
requestUrl
- URL to which request is to be sentcallMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be usedjava.io.IOException
public java.lang.String sendHttpRequest(HttpClient.HttpMethod callMethod, java.lang.String data) throws java.io.IOException
getConnectionUrl()
to get the URL and uses
specified HTTP method and sends data through request body. Obviously it is expected that user should set connectionUrl
property by invoking method setConnectionUrl(String)
beforehand.
It returns response that is expected to be textual such as a String. This method fits for using HTTP methods
POST, PUT or any other methods that allow passing info in the body request and there is some info to be sent.
If you don't need to send any info as request body, consider using method
sendHttpRequest(HttpMethod)
callMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be useddata
- String that holds the data to be sent as request bodyjava.io.IOException
public java.lang.String sendHttpRequest(java.lang.String requestUrl, HttpClient.HttpMethod callMethod, java.lang.String data) throws java.io.IOException
sendHttpRequest(String, HttpMethod)
requestUrl
- URL to which request is to be sentcallMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be useddata
- String that holds the data to be sent as request bodyjava.io.IOException
public java.nio.ByteBuffer sendHttpRequestForBinaryResponse(HttpClient.HttpMethod callMethod) throws java.io.IOException
getConnectionUrl()
to get the URL and uses
specified HTTP method. Obviously it is expected that user should set connectionUrl property by invoking method
setConnectionUrl(String)
beforehand.
This method is the same as sendHttpRequest(HttpMethod)
except that it returns ByteBuffer
that holds binary info. So this methods fits for retrieving binary response such as Image, Video, Audio or any
other info in binary format.callMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be usedByteBuffer
that holds response from URLjava.io.IOException
public java.nio.ByteBuffer sendHttpRequestForBinaryResponse(java.lang.String requestUrl, HttpClient.HttpMethod callMethod) throws java.io.IOException
sendHttpRequest(String, HttpMethod)
except that it returns ByteBuffer
that holds binary info. So this methods fits for retrieving binary response such as Image, Video, Audio or any
other info in binary format.requestUrl
- URL to which request is to be sentcallMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be usedByteBuffer
that holds response from URLjava.io.IOException
public java.nio.ByteBuffer sendHttpRequestForBinaryResponse(HttpClient.HttpMethod callMethod, java.lang.String data) throws java.io.IOException
getConnectionUrl()
to get the URL and uses
specified HTTP method. Obviously it is expected that user should set connectionUrl property by invoking method
setConnectionUrl(String)
beforehand.
This method is the same as sendHttpRequest(HttpMethod, String)
except that it returns
ByteBuffer
that holds binary info. So this methods fits for retrieving binary response such as Image,
Video, Audio or any other info in binary format.callMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be useddata
- String that holds the data to be sent as request bodyByteBuffer
that holds response from URLjava.io.IOException
public java.nio.ByteBuffer sendHttpRequestForBinaryResponse(java.lang.String requestUrl, HttpClient.HttpMethod callMethod, java.lang.String data) throws java.io.IOException
sendHttpRequest(String, HttpMethod, String)
except that it returns
ByteBuffer
that holds binary info. So this methods fits for retrieving binary response such as Image,
Video, Audio or any other info in binary format.requestUrl
- URL to which request is to be sentcallMethod
- HttpClient.HttpMethod
that specifies which HTTP method is to be useddata
- String that holds the data to be sent as request bodyByteBuffer
that holds response from URLjava.io.IOException
public java.lang.String getContentType()
@Deprecated public void setRequestProperty(java.lang.String headerName, java.lang.String headerValue)
setRequestHeader(String, String)
insteadheaderName
- if the value of header name is blank or null this method does nothingheaderValue
- Holds the value for the headerpublic void setRequestHeader(java.lang.String headerName, java.lang.String headerValue)
headerName
- if the value of header name is blank or null this method does nothingheaderValue
- headerValue Holds the value for the headerpublic java.lang.String removeRequestProperty(java.lang.String propertyName)
propertyName
- if the value of propertyName is blank or null this method does nothing and returns nullpublic void clearAllRequestProperties()
public void setContentType(java.lang.String contentType)
contentType
- holds content type valuepublic int getLastResponseCode()
public java.lang.String getLastResponseMessage()
public java.util.Map<java.lang.String,java.util.List<java.lang.String>> getLastResponseHeaders()
public java.util.Set<java.lang.String> getLastResponseHeaderNames()
public java.util.List<java.lang.String> getLastResponseHeader(java.lang.String fieldName)
fieldName
- - the name of the header field to be retrievedpublic TimeInterval getConnectTimeout()
TimeInterval
public void setConnectTimeout(TimeInterval connectTimeout)
setConnectTimeout(String)
,
setConnectTimeout(long, TimeUnit)
connectTimeout
- public void setConnectTimeout(java.lang.String timeIntervalStr) throws java.lang.IllegalArgumentException
TimeInterval
.timeIntervalStr
- that represents time interval. (See TextUtils.parseStringToTimeInterval(String)
to see
what is expected string format)java.lang.IllegalArgumentException
- if string parameter could not be parsed to TimeInterval
public void setConnectTimeout(long timeValue, java.util.concurrent.TimeUnit timeUnit) throws java.lang.IllegalArgumentException
TimeInterval
timeValue
- numeric time valuetimeUnit
- time unit to interpret time value unitjava.lang.IllegalArgumentException
- if timeValue is negative or TimeUnit is nullpublic TimeInterval getReadTimeout()
TimeInterval
public void setReadTimeout(TimeInterval readTimeout)
setReadTimeout(String)
,
setReadTimeout(long, TimeUnit)
readTimeout
- public void setReadTimeout(java.lang.String timeIntervalStr) throws java.lang.IllegalArgumentException
TimeInterval
.timeIntervalStr
- that represents time interval. (See TextUtils.parseStringToTimeInterval(String)
to see
what is expected string format)java.lang.IllegalArgumentException
- if string parameter could not be parsed to TimeInterval
public void setReadTimeout(long timeValue, java.util.concurrent.TimeUnit timeUnit) throws java.lang.IllegalArgumentException
TimeInterval
timeValue
- numeric time valuetimeUnit
- time unit to interpret time value unitjava.lang.IllegalArgumentException
- if timeValue is negative or TimeUnit is nullprotected java.net.HttpURLConnection openHttpUrlConnection(java.lang.String url, HttpClient.HttpMethod method) throws java.io.IOException
HttpURLConnection
to specified URL The connection's property
doOutput is set to falseurl
- Url to be connected tomethod
- HttpClient.HttpMethod
that specifies which HTTP Method to useHttpURLConnection
java.io.IOException
protected java.net.HttpURLConnection openHttpUrlConnection(java.lang.String url, HttpClient.HttpMethod method, boolean doOutput) throws java.io.IOException
HttpURLConnection
to specified URL.url
- Url to be connected tomethod
- HttpClient.HttpMethod
that specifies which HTTP Method to usedoOutput
- boolean value that specifies how to set connection's doOutput propertyHttpURLConnection
java.io.IOException
protected java.lang.String getDefaultContentType()
getContentType()
)


Making a Super Short Video
Introduction
Welcome folks! We made this little website to give you some tips to help you make thirty second to one minute videos that are clear, concise, fun, and effective. It's important to make sure your video is exciting and engaging, while still communicating your message. Just remember that making a video is more than narrarating a PowerPoint-style slideshow. You want to make sure you take full advantage of all the additional tools that videos offer. Don't worry, we'll show you how to do all this and more.
Before we get started in earnest, we want to take a moment to introduce ourselves and issue a quick caveat. We are both seniors majoring in computer science. We know what it's like to read a lot of boring text, so we tried to fill this website with videos and short easy to read articles (we also filled it with some typos too - you're welcome). Here's the caveat: The style of this website is extrememly informal. This was an intentional choice to try and make the site feel accessible to our peers. Your class presentations will likely need to make use of a much more formal style. That is to say, don't copy us; we're not doing it right. Now on to the good stuff!
There are three units to work through that are outlined below. Mostly, "working through" them involves watching videos and occasionally reading a short article or two. All in all, it's fast, it's quasi-fun, and it's definitely worth checking out. Enjoy!
Software
This unit lists several software options that may help you to make your thirty second videos. Some of the software is specific to the Windows or Mac platform, but we've given you some platform agnostic options as well.
Tips and Tricks
This is an important unit that with three subsections - basic communication guidelines with which you are likely already familiar, presentation techniques that you should keep in mind while planning your video, and tips for adding a touch of professionalism to your project.
Examples
In this unit, you'll watch some example videos and we'll point out some take key points where they hit the nail on the head or missed the mark slightly.


We provide support in banking transactions of arranging Term Loans, Working Capital and short term credit at reasonable rates. We drive out collections from customers of our clients so that monthly cash flows is maintained with limited borrowings to operate day to day operation of the business. We also function as a Statutory Regulator viz Central Excise, Service Tax ROC, Income Tax, VAT, PF and ESI registration, monthly returns and appeals etc.


Progress Bar Tests
Standard progress bar
Increment by 5%
A standard progress bar with all the default options.


Each coder demo is intended to illustrate a key PsychoPy feature (or two), especially in ways that show usage in practice, and go beyond the description in the API. The aim is not to illustrate every aspect, but to get people up to speed quickly, so they understand how basic usage works, and could then play around with advanced features.
As a newcomer to PsychoPy, you are in a great position to judge whether the comments and documentation are clear enough or not. If something is not clear, you may need to ask a PsychoPy contributor for a description; email<EMAIL_ADDRESS>Here are some style guidelines, written for the OpenHatch event(s) but hopefully useful after that too. These are intended specifically for the coder demos, not for the internal code-base (although they are generally quite close).
The idea is to have clean code that looks and works the same way across demos, while leaving the functioning mostly untouched. Some small changes to function might be needed (e.g., to enable the use of ‘escape’ to quit), but typically only minor changes like this.
Generally, when you run the demo, does it look good and help you understand the feature? Where might there be room for improvement? You can either leave notes in the code in a comment, or include them in a commit message.
Standardize the top stuff to have 1) a shebang with python, 2) utf-8 encoding, and 3) a comment:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Demo name, purpose, description (1-2 sentences, although some demos need more explanation).
"""
For the comment / description, it’s a good idea to read and be informed by the relevant parts of the API (see http://psychopy.org/api/api.html), but there’s no need to duplicate that text in your comment. If you are unsure, please post to the dev list<EMAIL_ADDRESS>Follow PEP-8 mostly, some exceptions:
Check all imports:
Fix any typos in comments; convert any lingering British spellings to US, e.g., change colour to color
Prefer if <boolean>: as a construct instead of if <boolean> == True:. (There might not be any to change).
If you have to choose, opt for more verbose but easier-to-understand code instead of clever or terse formulations. This is for readability, especially for people new to python. If you are unsure, please add a note to your commit message, or post a question to the dev list<EMAIL_ADDRESS>Standardize variable names:
Provide a consistent way for a user to exit a demo using the keyboard, ideally enable this on every visual frame: use if len(event.getKeys([‘escape’]): core.quit(). Note: if there is a previous event.getKeys() call, it can slurp up the ‘escape’ keys. So check for ‘escape’ first.
Time-out after 10 seconds, if there’s no user response and a timeout is appropriate for the demo (and a longer time-out might be needed, e.g., for ratingScale.py):
demoClock = core.clock() # is demoClock's time is 0.000s at this point
...
if demoClock.getTime() > 10.:
core.quit()
Most demos are not full screen. For any that are full-screen, see if it can work without being full screen. If it has to be full-screen, add some text to say that pressing ‘escape’ will quit.
If displaying log messages to the console seems to help understand the demo, here’s how to do it:
from psychopy import logging
...
logging.console.setLevel(logging.INFO) # or logging.DEBUG for even more stuff
End a script with win.close() (assuming the script used a visual.Window), and then core.quit() even though it’s not strictly necessary


{% extends "dashboard_z/www/templates/base_glossary.html" %} {% block title %} Dashboard {% endblock %} {% block content %}
There are many variations of passages of Lorem Ipsum available, but the majority have.
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration.


--- layout: default ---
This theme is more-or-less wemake-services/jekyll-theme-hackcss but gemified
so people can install it on their existing jekyll sites.
Head over to the hackcss site to get the official word.
Briefly, it's a simple css framework for markdownophiles.
Refer to the README.md
in the repo


--- title: "About" layout: page header-img: "img/about-bg.jpg" ---
Knock knock...
Hey there! This is Junxia. You can also call me Xavier. During my undergraduate study, I majored in Math & Applied Math. After graduating from Zhejiang University in June 2015, I spent 3 months as a research intern at Microsoft Research Asia System Group. My primary work at MSRA was to research computer game video compression method based on APIs. I obtained my Master degree from UCSanDiego in December 2016. I majored in Computer Science, machine learning track at UCSanDiego. I was an engineer intern at Snapchat in 2016. And now, I am a software engineer at Snapchat.


This is an EPICS areaDetector driver for the FastCCD detector produced by the detector group at Lawrence Berkeley National Laboratory. The driver is supported under Linux. The driver acts as a high level driver over a lower level c-driver which communicates with the camera via UDP sockets. The lower level c driver, libcin can be found on github here.
This driver inherits from ADDriver. It implements nearly all of the parameters in asynNDArrayDriver.h and in ADArrayDriver.h. It also implements a number of parameters that are specific to the FastCCD camera and can controll the boot-up sequence of the camera amd all settings such as bias voltages and timing.
The driver redefines the choices for several of the parameters defined in ADDriver.h. The ADTriggerMode choices for the FastCCD are:
The NDDataType choices for the FastCCD are:
The NDColorMode choices for the FastCCD are:
The FastCCD driver implements the following parameters in addition to those in asynNDArrayDriver.h and ADDriver.h:
| Parameter Definitions in FastCCD.cpp and EPICS Record Definitions in FastCCD.template | ||||||
| Parameter index variable | asyn interface | Access | Description | drvInfo string | EPICS record name | EPICS record type |
| FastCCD Image Size and Overscan Settings | ||||||
| FastCCDOverscanRows | asynParamInt32 | r/w | Specify the number of overscan rows to use when descrambling | OVERSCAN_ROWS |
$(P)$(R)OverscanRows $(P)$(R)OverscanRows_RBV |
longout longin |
| FastCCDOverscanCols | asynParamInt32 | r/w | Specify the number of overscan columns to use when descrambling | OVERSCAN_COLS |
$(P)$(R)OverscanCols $(P)$(R)OverscanCols_RBV |
longout longin |
| FastCCD CIN Power Settings | ||||||
| FastCCDPower | asynParamInt32 | r/w | Powers on and off the CIN (0 = off, 1 = on) | CIN_POWER |
$(P)$(R)Power $(P)$(R)Power_RBV |
bo bi |
| FastCCDFPPower | asynParamInt32 | r/w | Powers on and off the CIN front panel (0 = off, 1 = on) | CIN_POWER |
$(P)$(R)FPPower $(P)$(R)FPPower_RBV |
bo bi |
| FastCCD Power settings (Bias and Clocking) | ||||||
| FastCCDCameraPowerMode | asynParamInt32 | r/w |
Set the power mode of the FastCCD cmaera head to be turned on and off by FastCCDCameraPower. Possible values are: NONE CLOCKS BIAS BIAS AND CLOCKS |
CAMERA_POWER_MODE |
$(P)$(R)CameraPwrMode $(P)$(R)CameraPwrMode_RBV |
mbbo mbbi |
| FastCCDCameraPower | asynParamInt32 | r/w | Powers on and off the FastCCD camera head (0 = off, 1 = on) | CAMERA_POWER |
$(P)$(R)CameraPwr $(P)$(R)CameraPwr_RBV |
bo bi |
| FastCCDBias | asynParamInt32 | ro | Indicates if the CIN is requesting the camera head to turn on or off the bias power (0 = off, 1 = on) | BIAS | $(P)$(R)Bias_RBV |
bo bi |
| FastCCDClocks | asynParamInt32 | ro | Indicates if the CIN is requesting the camera head to turn on or off the clocking power (0 = off, 1 = on) | CLOCKS | $(P)$(R)Clocks_RBV |
bo bi |
| FastCCD fCRIC and CIN Settings | ||||||
| FastCCDMux1 | asynParamInt32 | r/w |
Set the output muxer on the CIN to monitor timing signals. Allowed values are: EXPOSE VCLK1 VCLK2 VCLK3 ATG VFSCLK1 VFSCLK2 VFSCLK3 HCLK1 HCLK2 OSW RST CONVERT SHUTTER SWTRIGGER TRIGMON |
FCCD_MUX1 |
$(P)$(R)Mux1 $(P)$(R)Mux1_RBV |
mbbo mbbi |
| FastCCDMux2 | asynParamInt32 | r/w |
Set the output muxer on the CIN to monitor timing signals. Allowed values are: EXPOSE VCLK1 VCLK2 VCLK3 ATG VFSCLK1 VFSCLK2 VFSCLK3 HCLK1 HCLK2 HCLK3 OSW RST CONVERT SAVE HWTRIG |
FCCD_MUX2 |
$(P)$(R)Mux2 $(P)$(R)Mux2_RBV |
mbbo mbbi |
| FastCCDFCRICGain | asynParamInt32 | r/w |
Sets the fCRIC gain. Allowed values are: Auto x2 x1 |
FCRIC_GAIN |
$(P)$(R)FCRICGain $(P)$(R)FCRICGain_RBV |
mbbo mbbi |
| FastCCDFCRICClamp | asynParamInt32 | r/w |
Sets the fCRIC clamp mode. Allowed values are: CLAMP OFF CLAMP ON |
FCRIC_CLAMP |
$(P)$(R)FCRICClamp $(P)$(R)FCRICClamp_RBV |
bo bi |
| FastCCDFOTest | asynParamInt32 | r/w |
Sets the fiberoptic module test mode. Allowed values are: Off On |
FO_TEST |
$(P)$(R)FOTest $(P)$(R)FOTest_RBV |
bo bi |
| FastCCD CIN Setting Upload | ||||||
| FastCCDFirmwarePath | asynParamOctet | r/w | Sets the path for the CIN firmware file to upload | FIRMWARE_PATH |
$(P)$(R)FirmwarePath $(P)$(R)FirmwarePath_RBV |
waveform |
| FastCCDFirmwareUpload | asynParamInt32 | r/w | Uploads the firmware to the CIN specified in the FastCCDFirmwarePath | FIRMWARE_UPLOAD |
$(P)$(R)FwUpload $(P)$(R)FwUpload_RBV |
busy bi |
| FastCCDClockPath | asynParamOctet | r/w | Sets the path for the clocking (timing) file to upload | CLOCK_PATH |
$(P)$(R)ClockPath $(P)$(R)ClockPath_RBV |
waveform |
| FastCCDClockUpload | asynParamInt32 | r/w | Uploads the clock (timing) to the CIN specified in the FastCCDClockPath | CLOCK_UPLOAD |
$(P)$(R)ClockUpload $(P)$(R)ClockUpload_RBV |
busy bi |
| FastCCDFCRICPath | asynParamOctet | r/w | Sets the path for the fCRIC configuration file to upload | FCRIC_PATH |
$(P)$(R)FCRICPath $(P)$(R)FCRICPath_RBV |
waveform |
| FastCCDFCRICUpload | asynParamInt32 | r/w | Uploads the fCRIC configuration to the CIN specified in the FastCCDFCRICPath | FCRIC_UPLOAD |
$(P)$(R)FCRICUpload $(P)$(R)FCRICUpload_RBV |
busy bi |
| FastCCDBiasPath | asynParamOctet | r/w | Sets the path for the sensor bias configuration file to upload | BIAS_PATH |
$(P)$(R)BiasPath $(P)$(R)BiasPath_RBV |
waveform |
| FastCCDBiasUpload | asynParamInt32 | r/w | Uploads the bias configuration to the CIN specified in the FastCCDBiasPath | BIAS_UPLOAD |
$(P)$(R)BiasUpload $(P)$(R)BiasUpload_RBV |
busy bi |
| FastCCD Auto Setting Parameters | ||||||
| FastCCDTimingMode | asynParamInt32 | r/w | Set the timing mode to use for auto booting the FastCCD | TIMING_MODE |
$(P)$(R)TimingMode $(P)$(R)TimingMode_RBV |
mbbo mbbi |
| FastCCDTimingName | asynParamOctet | ro | The name of the timing mode last set by the FastCCD auto boot sequence. | TIMING_NAME | $(P)$(R)TimingName_RBV | stringin |
| FastCCDTimingName0 | asynParamOctet | ro | The name of the timing mode assigned to mode number 1 | TIMING_NAME_0 | $(P)$(R)TimingName1_RBV | stringin |
| FastCCDTimingName1 | asynParamOctet | ro | The name of the timing mode assigned to mode number 2 | TIMING_NAME_1 | $(P)$(R)TimingName1_RBV | stringin |
| FastCCDTimingName2 | asynParamOctet | ro | The name of the timing mode assigned to mode number 3 | TIMING_NAME_2 | $(P)$(R)TimingName1_RBV | stringin |
| FastCCDTimingName3 | asynParamOctet | ro | The name of the timing mode assigned to mode number 4 | TIMING_NAME_3 | $(P)$(R)TimingName3_RBV | stringin |
| FastCCDTimingName4 | asynParamOctet | ro | The name of the timing mode assigned to mode number 5 | TIMING_NAME_4 | $(P)$(R)TimingName4_RBV | stringin |
| FastCCDTimingName5 | asynParamOctet | ro | The name of the timing mode assigned to mode number 6 | TIMING_NAME_5 | $(P)$(R)TimingName5_RBV | stringin |
| FastCCDTimingName6 | asynParamOctet | ro | The name of the timing mode assigned to mode number 7 | TIMING_NAME_6 | $(P)$(R)TimingName6_RBV | stringin |
| FastCCDTimingName7 | asynParamOctet | ro | The name of the timing mode assigned to mode number 8 | TIMING_NAME_7 | $(P)$(R)TimingName7_RBV | stringin |
| FastCCDTimingName8 | asynParamOctet | ro | The name of the timing mode assigned to mode number 9 | TIMING_NAME_8 | $(P)$(R)TimingName8_RBV | stringin |
| FastCCDTimingName9 | asynParamOctet | ro | The name of the timing mode assigned to mode number 10 | TIMING_NAME_9 | $(P)$(R)TimingName9_RBV | stringin |
| FastCCD Auto Setting Commands | ||||||
| FastCCDBoot | asynParamInt32 | r/w | Boot the CIN using the timing mode defined by FastCCDTimingMode. This causes the CIN to be reset (power cycled), the firmware to be uploaded and the timing to be uploaeded to the CIN. | BOOT |
$(P)$(R)Boot $(P)$(R)Boot_RBV |
busy bi |
| FastCCDSendTiming | asynParamInt32 | r/w | Send the timing information to the CIN as set by FastCCDTimingMode. This causes the CIN timing to change. | SEND_TIMING |
$(P)$(R)SendTiming $(P)$(R)SendTiming_RBV |
busy bi |
| FastCCDSendFCRIC | asynParamInt32 | r/w | Send the fCRIC configuration information to the CIN as set by FastCCDTimingMode. | SEND_FCRIC |
$(P)$(R)SendFCRIC $(P)$(R)SendFCRIC_RBV |
busy bi |
| FastCCDSendBias | asynParamInt32 | r/w | Send the bias voltage configuration information to the CIN as set by FastCCDTimingMode. | SEND_BIAS |
$(P)$(R)SendBias $(P)$(R)SendBias_RBV |
busy bi |
The FastCCD driver is created with the FastCCDConfig command, either from C/C++ or from the EPICS IOC shell.
int FastCCDConfig(char *portName,
int maxBuffers, size_t maxMemory,
int priority, int stackSize,
int packetBuffer, int imageBuffer,
const char *baseIP, const char *fabricIP,
const char *fabricMAC)
The packetBuffer and imageBuffer parameters specify how many packet frames and images to buffer in the libcin
driver. These are directly passed to libcin
on initialization.
The baseIP and fabricIP are the ip addresses of the base and fabric interfaces on the camera interface node (CIN). A null "" string sets the default as defined in the libcin
driver.
The fabricMAC parameter causes the libcin
driver to set the MAC address of the CIN on initialization. This can be used to broadcast the image data by using the FF:FF:FF:FF:FF
mac address.
For details on the meaning of the other parameters to this function refer to the detailed documentation on the FastCCDConfig function in the FastCCD.cpp documentation and in the documentation for the constructor for the FastCCD class.
Due to the multicolum nature of the FastCCD, setting the image size is not trivial. This is due to the nature of the image descrambling and if overscan is used on each supercolumn. For this reason the image size is governed by two paramaters, $(P)$(R)OverscanCols
and $(P)$(R)ADSizeY
.
The definition used for the image orientation in this driver is that columns are along the X direction and rows are along the Y direction. As the number of columns per supercolumn is fixed in timing to 10 columns, the only free parameter is the number of overscan cols to include and specified by the $(P)$(R)OverscanCols
PV. For this reason setting of the $(P)$(R)ADSizeX
PV is ignored by the driver. The number of rows defines how many rows per column to process and is set by the $(P)$(R)ADSizeY
PV.
The actual image size is therefore given by:
$(P)$(R)ADSizeY
[usually set to 2000 to have some overscan]$(P)$(R)OverscanCols
) * 96 [for no overscan 960]The FastCCD can be configured by using the built in firmware and settings in the libcin driver. This is controled by the PVs defined in the section FastCCD Auto Setting Commands. The PVs $(P)$(R)TimingName[0..9]_RBV
show strings with names defined in the libcin
driver corresponding to the modes 1 through 10. To boot into one of these modes, the user should set the PV $(P)$(R)TimingMode
to number of the mode required (0 through 9). The PV $(P)$(R)TimingName_RBV
will indicate the mode selected.
To boot the FastCCD, the user should write 1 to the PV $(P)$(R)Boot
. This will cause the FastCCD to reset the CIN (by power cycling it) and upload the firmware and timing configuration. At this point the user should be able to see the test pattern from the CIN by triggering the detector. The user can then configure the fCRICs by writing 1 to the PV $(P)$(R)SendFCRIC
. The bias configuration can be upload by writing 1 to the PV $(P)$(R)SendBias
. The latter two steps require the camera head to be powered. This is out of the scope of this driver.
MEDM screens are not used at NSLS-II as CSS-BOY is the default display manager
As the FastCCD CIN only uses UDP sockets, there is no permanent connection, the driver relies on being able to read such parameters as the serial nnumber of the software to be able to confirm that commuincation with the driver is occuring.


List comprehension is an alternative method of writing for
loops or lapply
(and similar) functions that is readable, quick, and easy to use. Many newcomers to R struggle with using the lapply
family of functions and default to using for
. However, for
loops are extremely slow in R and should be avoided. Comprehensions in the eList
package bridge the gap by allowing users to write lapply
or sapply
functions using for
loops.
This vignette describes how to use list and other comprehensions. It also explores comprehensions with multiple variables, if-else
conditions, nested comprehensions, and parallel comprehensions.
Let us start with a simple example: we have a vector of fruit names and want to create a sequence for each based on the number of characters. One common method is to write a for
statement where we loop across each fruit name, create a sequence from the numbers, and place it in a list.
x <- c("apples", "bananas", "pears")
fruit_chars <- vector("list", length(x))
for (i in seq_along(x)){
fruit_chars[[i]] <- 1:nchar(x[i])
}
fruit_chars
#> [[1]]
#> [1] 1 2 3 4 5 6
#>
#> [[2]]
#> [1] 1 2 3 4 5 6 7
#>
#> [[3]]
#> [1] 1 2 3 4 5
Alternatively, we could use a faster, vectorized function such as lapply
. This is similar to the for
loop, except that a specified function is applied to each fruit name and the results are wrapped in a list.
The eList
package allows for a hybrid variant of the two using the List()
function. The for
loop evaluates the expression and merges the results into a list. Beneath the scenes, List
is parsing the statement into lapply
and evaluating it. As we will see, though, there are additional features in List
.
library(eList)
#>
#> Attaching package: 'eList'
#> The following object is masked from 'package:stats':
#>
#> filter
#> The following object is masked from 'package:utils':
#>
#> zip
fruit_chars <- List(for (i in x) 1:nchar(i))
If you are coming from Python or another language that uses list comprehension, you will notice that this syntax is a bit different; it is written more similar to standard for
loops in R. The for
statement comes first, then the variable name and sequence are placed in parentheses. Finally the expression is placed afterwards. The expression can be wrapped in braces {}
if desired.
The lists of numbers in the previous examples may be confusing. Luckily, List
and other comprehension functions allow us to assign names to each result using the notation: name = expr
.
List(for (i in x) i = 1:nchar(i))
#> $apples
#> [1] 1 2 3 4 5 6
#>
#> $bananas
#> [1] 1 2 3 4 5 6 7
#>
#> $pears
#> [1] 1 2 3 4 5
The name can be any type of expression. Though complex expressions should be wrapped in parentheses so that the parser does not confuse who has the =
sign.
The results of a comprehension can be filtered using standard if
statements after naming the variables and sequence, making sure that the condition is placed in parentheses. The statement below only returns the sequence for "bananas"
.
Any statement that evaluates to NULL
is automatically filtered from the results. else
statements can also be included so that the results are not filtered out (unless the else
statement evaluates to NULL
).
List(for (i in x) if (i == "bananas") "delicious" else "ewww")
#> [[1]]
#> [1] "ewww"
#>
#> [[2]]
#> [1] "delicious"
#>
#> [[3]]
#> [1] "ewww"
Each entry can still be assigned a name. Furthermore, the expression can be as complex as necessary for the task with any number of else if
checks.
Comprehensions can have multiple variables if the variables are separated using "."
within a single name. To see how this works, let us use the enum
function in the eList
package. When enum
is used on a variable, the first value becomes its index in the loop and the second is the value of the vector at that index. Now, when we use (i.j in enum(x))
, i =
the index number of each item in x
, while j =
the value of the item in x
(the name of the fruit).
Let us inspect enum(x)
to see what is going on beneath the surface. enum
took the vector x
and created a new list at each index. The first list contains two elements: the first being 1
(the index number), the second being "apples"
(the first value in x
).
enum(x)
#> [[1]]
#> [[1]][[1]]
#> [1] 1
#>
#> [[1]][[2]]
#> [1] "apples"
#>
#>
#> [[2]]
#> [[2]][[1]]
#> [1] 2
#>
#> [[2]][[2]]
#> [1] "bananas"
#>
#>
#> [[3]]
#> [[3]][[1]]
#> [1] 3
#>
#> [[3]][[2]]
#> [1] "pears"
When multiple variables like i.j
are passed to the for
loop, then i
is assigned to the first element and j
to the second element for item in the sequence. There can be any number of variables as long as they are separated by "."
. There does not have to be a variable for each element; but there does need to be an element for each item or else an “out-of-bounds” error will be produced.
y <- list(a = 1:3, b = 4:6, c = 7:9)
List(for (i.j.k in y) (i+j)/k)
#> $a
#> [1] 1
#>
#> $b
#> [1] 1.5
#>
#> $c
#> [1] 1.666667
Similarly, variables can be skipped. The function below extracts the first and third elements of each item in the list.
If only the first or second item is needed, though, you should use two dots: i..
for the first, ..i
for the second.
Another convenient function that can be used on the sequence is items()
. It is similar to enum
, except that the name of each item is used instead of its index number. See the documentation for eList
for other helper functions.
All of the examples so far have returned a list. However, eList
supports a variety of different types of comprehension. For example, Num
returns a numeric vector, while Chr
returns a character vector. Env
can be used to produce an environment, similar to dictionary comprehensions in Python. Note that each entry in an environment must have a unique name. These work by coercing the result into particular type, producing an error if unable.
Num(for (i.j.k in y) (i+j)/k)
#> a b c
#> 1.000000 1.500000 1.666667
Chr(for (i.j.k in y) (i+j)/k)
#> a b c
#> "1" "1.5" "1.66666666666667"
One convenience function is ..
. It can be used as either ..[for ...]
or ..(for ...)
. By default, it attempts to simplify the results in an array, but can mimic any other type of comprehension.
Multiple for
loops can be used within a comprehension. As long the subsequent for
statements immediately follow the variables & sequence of the previous one, or immediately follow a if-else
statement, then it will be parsed into a vectorized lapply
style function. Nested loops should be avoided unless necessary since they can be difficult to understand. The following are a couple examples using matrix and numeric comprehension.
Mat(for (i in 1:3) for (j in 1:6) i*j)
#> [,1] [,2] [,3]
#> [1,] 1 2 3
#> [2,] 2 4 6
#> [3,] 3 6 9
#> [4,] 4 8 12
#> [5,] 5 10 15
#> [6,] 6 12 18
Vector Comprehensions can also be nested within each other. The code below nests a numeric comprehension within a character comprehension.
Vector comprehensions also for parallel computations using the parallel
package. All comprehensions allow the user to supply a cluster, which activates the parallel version of sapply
or lapply
. eList
comes with a function that allows for the quick creation of a cluster based on the user’s operating system and by auto-detecting the number of cores available. Users are recommended to explicitly create a cluster though the functions in the parallel
package unless a quick parallel calculation is needed.
cluster <- auto_cluster()
Num(for (i in 1:100) sample(1:100, 1), clust=cluster)
close_cluster(cluster)
Note that the additional overhead involved with parallelization means that the gain in performance will be relatively small (and often negative) unless the sequence is sufficiently large.
The eList
package contains a number of summary functions that accept vector comprehensions and/or normal vectors. These functions allow users to combine multiple comprehensions and other vectors in a single function, then apply a summary function to all entries. Each summary comprehension accepts a cluster for parallel computations and the na.rm
argument. Some examples:
# Are no values TRUE? (combines comprehension with other values)
None(for (i in 1:10) i < 0, TRUE, FALSE)
#> [1] FALSE
# Summary statistics from a random draw of 1000 observations from normal distribution
Stats(for (i in rnorm(1000)) i)
#> $min
#> [1] -3.832444
#>
#> $q1
#> [1] -0.6588868
#>
#> $med
#> [1] -0.01942801
#>
#> $q3
#> [1] 0.7268312
#>
#> $max
#> [1] 3.598601
#>
#> $mean
#> [1] 0.02125496
#>
#> $sd
#> [1] 1.018692
The following code compares the time associated with a naive for
loop, a standard sapply
function, vector comprehension using Num
, and a parallel version of Num
.
time_for <- mean(sapply(1:3, function(i){
system.time(
{
nums <- numeric(0)
for (j in 1:100000) nums <- c(nums, log(rnorm(1, 1000, 10)) + 1)
}
)
}))
time_sapply <- mean(sapply(1:3, function(i){
system.time(
sapply(1:100000, function(j) log(rnorm(1, 1000, 10)) + 1)
)
}))
time_comp <- mean(sapply(1:3, function(i){
system.time(
Num(for (i in 1:100000) log(rnorm(1, 1000, 10)) + 1)
)
}))
cluster <- auto_cluster()
time_parallel <- mean(sapply(1:3, function(i){
system.time(
Num(for (i in 1:100000) log(rnorm(1, 1000, 10)) + 1, clust=cluster)
)
}))
close_cluster(cluster)
cat(paste0("for Loop: ", time_for, "\nsapply: ", time_sapply, "\nNum: ",
time_comp, "\nNum-Prll: ", time_parallel, "\n"))
#> for Loop: 4.84686666666667
#> sapply: 0.0964000000000002
#> Num: 0.102133333333334
#> Num-Prll: 0.0336000000000006


public class TCPConnection
extends java.lang.Object
| Constructor and Description |
|---|
TCPConnection() |
TCPConnection(java.lang.String address,
int commandPort,
int objectPort) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
close()
Closes both command and object connections
|
void |
connect(java.lang.String address,
int commandPort,
int objectPort)
Opens connections (command and object) to a slave
|
void |
finalize() |
DataBuffer |
getLastResponsePack() |
Slave |
getSlave()
Returns the associated slave
|
boolean |
result()
Get test responses from server.
|
boolean |
run(java.lang.String address,
int port)
Sends a run command to start the test scenario
|
boolean |
send(AbstractTest test,
java.lang.String protocolName)
Sends a test to the connected slave
|
void |
setSlave(Slave slave)
Modifies the associated slave.
|
boolean |
stop()
Sends a Stop message to stop the test processing into the slave
|
public TCPConnection() throws java.io.IOException
java.io.IOException
public TCPConnection(java.lang.String address, int commandPort, int objectPort) throws java.net.UnknownHostException, java.io.IOException
java.net.UnknownHostException
java.io.IOException
public void finalize()
finalize
in class java.lang.Object
public void connect(java.lang.String address, int commandPort, int objectPort) throws java.net.UnknownHostException, java.io.IOException
address
- network address of the slavecommandPort
- the port for sending commandsobjectPort
- the port for sending objectsjava.net.UnknownHostException
java.io.IOException
public boolean close()
public Slave getSlave()
public void setSlave(Slave slave)
slave
- a slavepublic DataBuffer getLastResponsePack()
public boolean send(AbstractTest test, java.lang.String protocolName)
test
- a test to sendpublic boolean stop()
public boolean run(java.lang.String address, int port)
address
- the address of the tested serverport
- the port of the tested protocolpublic boolean result()


Clicking in the blue box will pop up a "Hello World!" alert window. Clicking on the first link will take you to the YUI website; clicking on the second link, which has the same href
attribute, will pop up an alert instead and not navigate to a new page.
Event Utility is used here to do two things:
click
event handler to the blue box;<a>
element that uses preventDefault()
to prevent the link, when clicked, from navigating to a new page. Click for Hello World alert.
Compartment 1 content here...
item 2 content here...
Compartment 1 content here...


A set is an abstract data type that is similar to a bag. It is also unordered, but it does not allow duplicates. Examples of sets would be even integers or a collection of the movies you have previously seen. Which bag behavior would need to be modified for a set?
hint 1 would go here lastIndex
hint 2 would go here


What is being asked in the problem?
Will you complete for the exact time that Rod spent in jogging?
What will you do then?
Estimate the amount of time spent by Rod in jogging.
How will you do it? Round the times in minutes.
Study this.
Subtract the rounded times.
Therefore : Rod jogged for about 40 minutes.
Try to round the actual elapsed time . Is your answer reasonable?
Let's Practice!Find the estimated and actual elapsed times in each situation below :
1. The Tabilang family arrived in Buluarte at 10:28 in the morning. They left their house at 10:05am.
Estimated elapsed time : 20 minutes
Actual time : 23 minutes
2. Lolita started eating her dinner at 6:35pm and finished eating at 7:03pm.
Estimated elapsed time : 30 minutes
Actual time : 28 minutes
3. Section A of the Grade 4 class of Sudipen Central Elemtary School started their tour around Barangay Poblacion at 8:06am. They were back to school at 8:58am.
Estimated elapsed time : 50 minutes
Actual time : 52 minutes


Stereotype threat is a term coined by social psychologist Dr. Claude Steele. It refers to the fear of confirming a negative stereotype about the group to which one belongs. This can happen along the lines of race, age, gender, sexual identity, socioeconomic status, or likely any other physical or psychosocial attribute (for example, I could imagine stereotype threat happening among those who suffer from chronic illness or mental illness, or those who have a disability).
I cannot personally speak to some of the experiences above, but I can relate my experiences as a woman. I'd like to preface this by acknowledging that my experiences are those of a white, straight, cis woman, and not intended to disregard or minimize the additional struggles that may be faced by those who identify as LGBT and/or people of color (or any other underserved or underrepresented group as above). In other words, I know that I am still benefitting from some major societal privileges despite what I'm going to talk about here.
The older I get, the more I seem to find myself at odds with two warring parts of my identity. On the one hand, I don't want to be held back (or hold myself back) by being a woman. I want to thrive in a field that is currently dominated by men, and that's going to take some backbone. But the other part of me has been thoroughly conditioned over the past 29 years to adhere to all of the expectations of being a woman. This involves ultimately being nice, putting others' needs before my own, avoiding conflict, and not trusting my own thoughts/ideas/feelings.
I have found this to be especially true in written and verbal communication. If you've followed anything in the news about vocal fry or uptalk, you know that women are constantly being criticized for how they speak. Our tendency towards qualifiers and words such as like and just also comes up in our writing. When I wrote emails to my patients as a dietitian, I often felt like it would be so much faster to simply pick up the phone to answer their questions because I wasted so much time proofreading my emails. I needed to sound both authoritative as a nutrition professional and approachable as a confidant.
This strange dichotomy is felt elsewhere in the workplace by women, too. When it comes to asking for a raise or promotion, you're damned if you do and damned it you don't. Keeping quiet makes it much more likely that you'll be passed over, but standing up for yourself might get you labeled "too aggressive." I've experienced both. As a result, I am simultaneously determined to stick up for myself in a future salary negotiation and seriously questioning whether I'm actually capable of doing so.
Here are some other instances of stereotype threat that many women will likely identify with:
In other words, what we experience is a self-fulfilling prophecy. "If I say/do _______, and it's perceived as _______, then they'll know that I'm inferior because I am a woman." This behavior is not responsible for the societal perception of women as inferior, rather it is reflective of it.
So what do we do? How do we adapt? I'm not sure that I have the answers to those questions. For me personally, I think that I need to learn to have more confidence in myself and my abilities without so much anxiety about how I am perceived as a woman (in tech or otherwise). I need to remember that there are more facets to my personality than simply my gender, and I need to give others the benefit of the doubt that they are not merely judging me on such a shallow level. There are also helpful ideas for reducing stereotype threat of all kinds listed here.


TechWizard

Do you reckon that you are at par with the analytics in your code!!!. Time to push your boundaries and stand
out in the crowd with TechWiZ. The event comprises of challenges ranging from debugging to blind coding and will
allow the participants to delve deep into the diminutive tracks of competitive coding. TechWiZ provides a perfect
room for participants to assess their coding skills with the timers muddling with their brains for maintaining
a competitive instinct.
TIMINGS
Stay Tuned....


Here are the rules. There are no rules.
Just update the form whenever you can. You don't have to fill out all of the boxes at the same time; in fact, it's preferred if you fill em out throughout the day (and night).
There's a datechecker thingie here, which means that you can change values so long as you do it on the same day you submitted your original response.


Education
Skills
Working Experience
Course Projects
Tasks
Main Page
Subscribe
Current Subscriber
Card Title
Wellcome to Yen-Teh Liu's personal website. Know more about me by viewing my linkedin and Instagram
My Favorite Cities
Instagram
Linkedin
Contact me
Subscribe
Name
Email


Man Vs.
Man Vs. is a movie starring Chris Diamantopoulos, Chloe Bradt, and Michael Cram. A mysterious stalker plagues a reality tv survivalist during his five days alone for a new season of his show in the northern Ontario wilderness; and...


dazl.model
package¶
The dazl.model
module is the low-level domain model for the Ledger. Most of the time, these
classes will not be instantiated directly, but will frequently be passed to your code to work with.
The most important classes:
dazl.model.core
:dazl.model.writing
:Subclasses of
Command
for the Write API:CreateCommand
andExerciseCommand
dazl.model.types
:Type description classes: Subclasses of
Type
:ScalarType
,ListType
,RecordType
,VariantType
Core types¶
The dazl.model.core
module contains classes used on both the read-side and the write-side of
the Ledger API.
-
class
dazl.model.core.
ContractId
(contract_id: str, template_id: Union[None, str, Type] = None)[source]¶ There are two kinds of contract IDs: those that know the template type of the underlying contract instance and those that don’t. Contract IDs that arise from event processing are always tagged with their type when they are read off the event stream. Contract IDs that are parameters to a template are not currently tagged with a template type.
Instance attributes:
-
contract_id
¶ A
str
reference to a contract.
-
template_id
¶ An optional
str
template ID.
Instance members:
-
exercise
(choice_name, arguments=None)[source]¶ Create an
ExerciseCommand
that represents the result of exercising a choice on this contract with the specified choice.- Parameters
choice_name – The name of the choice to exercise.
arguments – (optional) A
dict
of named values to send as parameters to the choice exercise.
-
for_json
()[source]¶ Return the JSON representation of this contract. This is currently just the contract ID string itself.
-
replace
(contract_id=None, template_id=None)[source]¶ Return a new
ContractId
instance replacing specified fields with values.
-
Types that describe the behavior of the ledger itself.
Read-Side Types¶
This module contains models used on the read-side of the Ledger API.
-
class
dazl.model.reading.
InitEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore)[source]¶ Event raised when dazl is initialized, but before it has begun reading from the Active Contract Set (ACS).
-
class
dazl.model.reading.
InitEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore)[source] Event raised when dazl is initialized, but before it has begun reading from the Active Contract Set (ACS).
-
class
dazl.model.reading.
OffsetEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str)[source]¶ Event raised when dazl is ready to begin processing new events. At this point, the Active Contract Set (ACS) is populated with the current state of the ledger.
-
class
dazl.model.reading.
ReadyEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str)[source]¶ Event raised when dazl is ready to begin processing new events. At this point, the Active Contract Set (ACS) is populated with the current state of the ledger.
-
class
dazl.model.reading.
ActiveContractSetEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, contract_events: Sequence[ContractCreateEvent])[source]¶ Event raised on initial read of the active contract set.
-
class
dazl.model.reading.
BaseTransactionEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str)[source]¶ Event raised when dazl encounters a new transaction. This is raised before any corresponding
ContractCreateEvent
orContractArchiveEvent
.
-
class
dazl.model.reading.
TransactionStartEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, contract_events: Sequence[ContractEvent])[source]¶ Event raised when dazl encounters a new transaction. This is raised before any corresponding
ContractCreateEvent
orContractArchiveEvent
.
-
class
dazl.model.reading.
TransactionEndEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, contract_events: Sequence[ContractEvent])[source]¶ Event raised when dazl encounters the end of a transaction. This is raised after any corresponding
ContractCreateEvent
orContractArchiveEvent
.
-
class
dazl.model.reading.
ContractEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, cid: dazl.model.core.ContractId, cdata: Dict[str, Any], event_id: str, witness_parties: Sequence[str])[source]¶ Event raised when dazl automation detects a new create or an archive. The Active Contract Set (ACS) reflects this event, as well as all other events that occurred in the same transaction.
-
class
dazl.model.reading.
ContractCreateEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, cid: dazl.model.core.ContractId, cdata: Dict[str, Any], event_id: str, witness_parties: Sequence[str])[source]¶ Event raised when dazl automation detects a contract create. The Active Contract Set (ACS) reflects this event, as well as all other events that occurred in the same transaction.
-
class
dazl.model.reading.
ContractExercisedEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, cid: dazl.model.core.ContractId, cdata: Dict[str, Any], event_id: str, witness_parties: Sequence[str], contract_creating_event_id: str, choice: str, choice_args: Any, acting_parties: Sequence[str], consuming: True, child_event_ids: Sequence[str])[source]¶ Event raised when dazl automation detects a contract exercised.
-
class
dazl.model.reading.
ContractArchiveEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, offset: str, command_id: str, workflow_id: str, cid: dazl.model.core.ContractId, cdata: Dict[str, Any], event_id: str, witness_parties: Sequence[str])[source]¶ Event raised when dazl automation detects a contract archive. The Active Contract Set (ACS) reflects this event, as well as all other events that occurred in the same transaction.
-
class
dazl.model.reading.
PackagesAddedEvent
(client: Any, party: Optional[NewType.<locals>.new_type], time: Optional[datetime.datetime], ledger_id: str, package_store: dazl.model.types_store.PackageStore, initial: bool)[source]¶ Event raised when new packages have been detected.
-
class
dazl.model.reading.
TransactionFilter
(ledger_id:str, current_offset:Union[str, NoneType], destination_offset:Union[str, NoneType], templates:Union[Collection[dazl.model.types.Type], NoneType], max_blocks:Union[int, NoneType], party_groups:Union[Collection[str], NoneType])[source]¶
-
class
dazl.model.reading.
EventKey
[source]¶ -
static
contract_archived
(primary_only: bool, template: Any) → Collection[str][source]¶ Return the names of events that get raised in response to a
ContractCreateEvent
of the specified template type.
-
static
contract_created
(primary_only: bool, template: Any) → Collection[str][source]¶ Return the names of events that get raised in response to a
ContractCreateEvent
of the specified template type.
-
static
contract_exercised
(primary_only: bool, template: Any, choice: Any) → Collection[str][source]¶ Return the names of events that get raised in response to a
ContractExercisedEvent
of the specified choice.
-
static
init
() → Collection[str][source]¶ Return the names of events that get raised in response to an
InitEvent
. This is currently only'init'
.
-
static
offset
() → Collection[str][source]¶ Return the names of events that get raised in response to a
OffsetEvent
. This is currently only'offset'
.
-
static
ready
() → Collection[str][source]¶ Return the names of events that get raised in response to a
ReadyEvent
. This is currently only'ready'
.
-
static
transaction_end
() → Collection[str][source]¶ Return the names of events that get raised in response to a
TransactionEndEvent
. This is currently only'transaction-end'
.
-
static
transaction_start
() → Collection[str][source]¶ Return the names of events that get raised in response to a
TransactionStartEvent
. This is currently only'transaction-start'
.
-
static
Type system types¶
The dazl.model.types
module contains the Python classes used to represent the DAML type
system.
DAML type |
Python type |
|---|---|
|
|
|
|
|
|
|
|
-
class
dazl.model.types.
ScalarType
(name: str)[source]¶ A DAML-defined type that represents a simple scalar value. You should not need to ever construct instances of this directly; all scalar types are builtins.
-
class
dazl.model.types.
RecordType
(named_args: dazl.model.types.NamedArgumentList, name: Optional[dazl.model.types.TypeReference], type_args: Sequence[dazl.model.types.TypeVariable], adjective: dazl.model.types.TypeAdjective)[source]¶
Write-Side types¶
The dazl.model.writing
module contains the Python classes used on the write-side of the
Ledger API.
-
class
dazl.model.writing.
CreateCommand
(template: Union[str, dazl.model.types.Type], arguments=None)[source]¶ A command that creates a contract without any predecessors.
-
template
¶ Refers to the type of a template. This can be passed in as a
str
to the constructor, where it assumed to represent the ID or name of a template.
-
arguments
¶ The arguments to the create (as a
dict
).
-
replace
(template: Union[None, str, dazl.model.types.Type] = None, arguments=None)[source]¶ Create a new
CreateCommand
with the same identifier as this command, but with new values for its parameters.- Parameters
template – The new value of the template field, or None to reuse the existing value.
arguments – The new value of the arguments field, or None to reuse the existing value.
-
-
class
dazl.model.writing.
ExerciseCommand
(contract: Union[str, dazl.model.core.ContractId], choice: str, arguments=None, template_id=None)[source]¶ A command that exercises a choice on a pre-existing contract.
-
contract
¶ The
ContractId
on which a choice is being exercised.
-
choice
¶ Refers to a choice (either a
ChoiceRef
or aChoiceMetadata
). This can be passed in as astr
to the constructor, where it assumed to represent the name of a choice.
-
arguments
¶ The arguments to the exercise choice (as a
dict
).
Note that when an
ExerciseCommand
is created, an additionaltemplate_id
parameter can be supplied to the constructor to aid in disambiguation of the specific choice being invoked. In some situations involving composite commands, atemplate_id
must eventually be supplied before a choice can be exercised. If thistemplate_id
is specified, thecontract
andchoice
are both tagged with this ID.Instance methods:
-
replace
(contract=None, choice=None, arguments=None, template_id=None)[source]¶ Create a new
ExerciseCommand
with the same identifier as this command, but with new values for its parameters.- Parameters
contract – The new value of the contract field, or None to reuse the existing value. The same type coercion rules used in the constructor apply here.
choice – The new value of the choice field, or None to reuse the existing value. The same type coercion rules used in the constructor apply here.
arguments – The new value of the choice field, or None to reuse the existing value.
template_id – The expected template type.
-
replace
(contract=None, choice=None, arguments=None, template_id=None)[source] Create a new
ExerciseCommand
with the same identifier as this command, but with new values for its parameters.- Parameters
contract – The new value of the contract field, or None to reuse the existing value. The same type coercion rules used in the constructor apply here.
choice – The new value of the choice field, or None to reuse the existing value. The same type coercion rules used in the constructor apply here.
arguments – The new value of the choice field, or None to reuse the existing value.
template_id – The expected template type.
-


{% extends "base.html" %} {% block extend_head %} {% endblock extend_head %} {% block content %} {% for assignment in assignments %}


Thank you for trying the plugin. Please visit my website and give me some love by send me your comment. ^.^
Made by ChenX (email:chenxeed@gmail.com)


Prospectus - 1.9.0
Posted: Sat Sep 13, 2008 10:11 pm
- Allow client to see FPS on screen
- add "hot corners" to show buttons for:
- top left - taking action on things in the world ("private chat with", "trade with", etc)
- top right - viewing static screens (inventory, stats, key settings)
- introduce genisite, geosids, portals and the chaos plane
- add the (awesome!) new meshes for aurelian items
- examine memory leaks
- landmarks?
- ability to delete characters
- see race/class on stats screen
- left hand/right hand configuration
- make players able to configure unique colors
- "esc" closes inventory/keys screen


This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer. This is a wider card with supporting text below as a natural lead-in to additional content. This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
| Name | Creator | Type | Start Date | End Date | Supervisor | Action |
|---|---|---|---|---|---|---|
| PFE | 07 may, 18 | 07 June, 18 |
|
|||
| Jacob | Thornton | @fat | ||||
| Larry | the Bird |


Demo Table Of Candidates
| Name |
Skills |
| Cirpo |
JavaScript, Docker |
| Louis |
Java, AEM |
| Nermin |
.NET, Azure |
Candidates (Filtered By JavaScript Skills)
Candidates (Filtered By AWS Skills)
Candidates (Filtered By Python Skills)
Candidates (Filtered By Azure Skills)


Structure
The following page shows some of the fundamentals of importing compas_fea classes and usage of the main Structure object, including some of the Structure object’s most important methods and attributes.
Importing modules and classes
A Python .py file is created for every compas_fea model and analysis, which is where an empty Structure object is first instantiated and then populated with the components needed for the model. To import these components and use other helper functions from the core compas or compas_fea packages, import
statements are needed in the first few lines of the Python file. For example, if the user wishes to use a CAD environment for extracting geometry or visualising analysis results, either of the following lines below could be written to use Rhinoceros or Blender. These imports will make a variety of functions available from the compas_fea.cad.blender and compas_fea.cad.rhino modules.
from compas_fea.cad import rhino
from compas_fea.cad import blender
It is useful to use packages, modules and functions from the core compas library, especially compas.geometry and compas.datastructure imports to help build the Structure object:
from compas.datastructures import Mesh
from compas.geometry import distance_point_point
There are also many functions from the core compas CAD packages that can be helpful for creating, editing or deleting objects and layers:
from compas_blender.utilities import clear_layers
from compas_blender.utilities import delete_objects
The most important imports will be for retrieving classes from compas_fea.structure, including the main Structure class itself. Imports, like with the main compas library, are always available from the second level, with embedded modules pulled up to enable this. This is particularly useful for all of the classes found in compas_fea.structure. These special classes make important objects for the model and will be described in more detail throughout the various tutorial topics.
from compas_fea.structure import GeneralStep
from compas_fea.structure import PointLoad
from compas_fea.structure import Structure
The top of the .py file might look something like:
from compas.datastructures import Mesh
from compas.geometry import distance_point_point
from compas_rhino.helpers import mesh_from_guid
from compas_fea.cad import rhino
from compas_fea.structure import BucklingStep
from compas_fea.structure import Concrete
from compas_fea.structure import ElementProperties as Properties
from compas_fea.structure import GeneralStep
from compas_fea.structure import GravityLoad
from compas_fea.structure import PointLoad
from compas_fea.structure import RectangularSection
from compas_fea.structure import RollerDisplacementY
from compas_fea.structure import ShellSection
from compas_fea.structure import Steel
from compas_fea.structure import Structure
from compas_fea.structure import TrussSection
Structure object
The container for all model and analysis data is the Structure object, created from the Structure class. All of the attributes and methods of this class can be found at compas_fea.structure.structure, with the most important methods demonstrated here and throughout the other topics of the tutorial, so see the various topics on the left-hand-side to understand how to add all the various data and objects to the Structure object. The following code creates an empty Structure object named mdl
(used in the tutorial and examples as a short-cut handle).
from compas_fea.structure import Structure
mdl = Structure(name='simple-truss', path='/home/al/Temp/')
The files that are generated when using the compas_fea package, will all be saved in a folder named path
, with many temporary files stored within this location under another folder called path/name
. These arguments can be passed when instantiating the Structure object like above, or by changing the attributes directly at a later time.
mdl.name = 'new-truss'
mdl.path = '/home/al/Folder/'
The above pairing will produce files such as /home/al/Folder/new-truss.inp (an Abaqus input file) and /home/al/Folder/new-truss.obj. Additional temporary files, including output .json data and analysis output databases such as an Abaqus .odb file will be stored in /home/al/Folder/new-truss/, this is to keep things organised as an analysis will often generate hundreds of output files.
Summary
Once constructed, a top-down summary of the Structure object can be printed with method .summary()
or by printing the object print(mdl)
. This will print information to the terminal such as the number of nodes and elements, the name of sets and how many items in their selection, and the name and type of added objects such as Materials, Sections, Loads, Displacements and Steps. This summary is useful for checking that nodes, elements and objects have been added correctly before any analysis is performed. If no objects of a particular type are present in that attribute of the Structure, then n/a is printed.
>>> mdl.summary()
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
compas_fea Structure: truss_frame
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Nodes
-----
56
Elements
--------
158
Sets
----
elset_diag : 105 element(s)
elset_main : 51 element(s)
nset_load_v : 6 node(s)
elset_stays : 2 element(s)
nset_load_h : 2 node(s)
nset_pins : 8 node(s)
Materials
---------
mat_steel : Steel
Sections
--------
sec_diag : TrussSection
sec_main : TrussSection
sec_stays : TrussSection
Loads
-----
load_pl_h : PointLoad
load_pl_v : PointLoad
load_gravity : GravityLoad
Displacements
-------------
disp_pinned : PinnedDisplacement
Constraints
-----------
n/a
Interactions
------------
n/a
Misc
----
n/a
Steps
-----
step_bc : GeneralStep
step_loads : GeneralStep
Loading and saving
The methods to save and load a Structure object are .save_to_obj()
and .load_from_obj()
. Saving the Structure will use the .path
and .name
attribute strings for creating the file name, whilst the file name string filename
must be given for loading an existing .obj. These operations will save or load data as a pickled object using Pickle, containing all populated dictionaries and objects. A confirmation message will be displayed upon each save and load call.
>>> mdl.save_to_obj()
***** Structure saved to: /home/al/Temp/simple-truss.obj *****
>>> mdl = Structure.load_from_obj(filename='/home/al/Temp/simple-truss.obj')
***** Structure loaded from: /home/al/Temp/simple-truss.obj *****


This package contains four datasets from an urban water and sanitation survey in Dhaka, Bangladesh conducted by Water and Sanitation for the Urban Poor with technical support from Valid International in March 2017.
popBGD
: Dataset on estimated population of each primary sampling unit (PSU) that were surveyed. This dataset is a mix of data from WorldPop for the non-slum areas and from the 2014 Bangladesh Census of Slum Areas and Floating Population.
ppiMatrixBGD
: Look-up table for calculating the Poverty Probability Index
(previously called Progress out of Poverty Index
) or PPI
from Bangladesh-specific indicators collected from cross-sectional surveys. This look-up table is extracted from documentation of the PPI
found at https://www.povertyindex.org
surveyDataBGD
: Dataset collected through the urban water and sanitation surveys conducted by WSUP in Dhaka, Bangladesh.
indicatorsDataBGD
: Dataset produced from surveyDataBGD
by calculating relevant indicators on water, sanitation and hygiene as specified and defined by WSUP
This survey in Dhaka is one of a series of surveys to be conducted by WSUP in various cities in which they operate including Accra, Ghana; Nakuru, Kenya; Antananarivo, Madagascar; Maputo, Mozambique; and, Lusaka, Zambia. This package will be updated once the surveys in other cities are completed and datasets have been made available.
To install the package, type the following in R:
install.packages("washdata")
library(washdata)
Install development version of the package via GitHub:
devtools::install_github("validmeasures/washdata")
library(washdata)


Film review by Kevin Patterson
ARMAGEDDON Rating: **1/2 (out of four) PG-13, 1998 Director: Michael Bay Producer: Jerry Bruckheimer Screenplay: Jonathan Hensleigh and J.J. Abrams Starring Cast: Bruce Willis, Billy Bob Thornton, Ben Affleck, Liv Tyler, Steve Buscemi.
After GODZILLA disappointed, both critically and commercially, and DEEP IMPACT turned out not to be an action movie in the strict sense, July of 1998 has rolled around without an action blockbuster having hit the theaters. Expectations have accordingly been high for ARMAGEDDON, in which a team of roughnecks led by Harry Stamper (Bruce Willis) are sent into outer space for the purpose of drilling a hole inside an asteroid on a collision course with Earth and then blowing it up from the inside. It certainly seems to have all the right ingredients: it has Bruce Willis in the lead, it has a premise ripe with potential for big explosions and stunts (along with a bit of flag-waving), and the producer/director team of Jerry Bruckheimer and Michael Bay had been responsible for the 1996 action hit THE ROCK.
Unfortunately, that's really about all it has. Don't misunderstand: ARMAGEDDON entertains. But aside from the few real moments of heroism at the end, I liked it mostly for the same reasons that Beavis and Butt-head would probably like it: because a lot of stuff got blown up, and that was cool. Since its plot (Our Heroes vs. Big Inanimate Object) is about as thin as they come, it has to keep moving mostly on the basis of Murphy's Law: a fuel tank explodes during an intermediate stop at a space station, one of the two shuttles is damaged by debris from the asteroid, the nuclear bomb intended to destroy the asteroid is about to go off early, the drills keep breaking, a character comes down with "space dementia," and finally the bomb mechanism is broken and someone has to stay behind and detonate the bomb manually.
I won't waste time pointing out how the storyline is implausible (which it is), since these kinds of movies do not sink or swim with their scientific credibility. I will point out, however, that it's kind of sloppy. The screenplay reportedly passed through the word processors of nine different writers, and it shows in places. There are a few characters introduced towards the beginning, such as a goofy astronomer with a nagging wife and a few New York City tourists who get scared up by a meteor shower, who then disappear with no indication of why they were in the script in the first place. Steve Buscemi's character, Rockhound, apparently got his Ph.D at age 22, yet he later makes an asinine comment about how NASA's proposed flight plan resembles a failed stunt from a Road Runner cartoon that would insult the intelligence of most high school physics students. There's also some hokey dialogue that I would have thought at least one of the nine writers ought to have edited. (Note to whoever was responsible for the scene where the bomb is about to go off: it's fine to write a scene that turns into a surrealistic nightmare, but actually having a character announce "This has turned into a surrealistic nightmare!" doesn't come off too well.)
Characters in these kinds of action movies don't have to be well-developed, but they at least ought to be animated and fun to watch. Aside from Harry Stamper and Rockhound, most of them are pretty bland: the rest of Stamper's squad consist of pretty much stock macho characters. Their tough-guy antics in front of the NASA training team and sarcastic one-liners are mildly amusing, but the only time I really laughed out loud was when Buscemi started trying to replicate a scene from DR. STRANGELOVE. For a movie that barely comes in under the 150-minute mark, some of this seems like dead weight (not to mention that it completely undermines any sense that the world might really be about to end, but I'm not even going to get started on that). There's also a romance between A.J. (Ben Affleck) and Harry's daughter Grace (Liv Tyler) that doesn't add a whole lot to the story.
Director Michael Bay keeps the action going pretty much non-stop for the final half of the movie. While it certainly serves to keep the audience's adrenaline rushing, some of it unfolds in a rather confusing way. I'm still not sure exactly what went wrong on board the space station: all I know was that there were some sparks flying, some incomprehensible shouting from a Russian cosmonaut (Peter Stormare), and then a Narrow Escape and a Big Explosion. There's nothing visually distinct about ARMAGEDDON except for a few surface shots of the asteroid: at one point, the flying rock, the shouting, and the camera-shaking went on for so long that I actually caught myself starting to tune out for about a minute, and that's one thing that shouldn't happen in an action movie.
ARMAGEDDON turns up the action meter in a way few movies often do, but its coherence meter is somewhere near the bottom. It's good entertainment, and it meets the minimum requirements for a summer blockbuster. Still, I'd be surprised if I remember much of it a year from now. Except, of course, that a lot of stuff got blown up. And that was cool.

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Why Microsoft Shareholders Should be Very Concerned
This weeks Partner’s conference has once again exposed Microsoft’s complete lack of any credible consumer strategy. On the one hand Ballmer claims he’s going to leave no «stone unturned» competing with Apple. Yet on the same day he also states that Microsoft’s own Windows 8 hardware «Surface is just a design point.» Note to Steve: Those are two mutually incompatible objectives.
If Ballmer really is serious about competing with Apple then Microsoft will need to control its own hardware destiny — in pcs, tablets and smartphones — and be completely committed to that strategy. Unfortunately that will also require a willingness to throw the OEM partner community under the bus. Protecting OEMs while aggressively competing with Apple are incompatible strategies. A textbook case of the Innovators dilemma.
Shareholders are likely to pay a very high price if Ballmer continues to believe the fantasy that he can accomplish both these competing objectives and still be successful in the consumer business.


Startup
Welcome to Startup
Sign in to your account.
Email
Password
Forgot your password?
Sign In
Don't have an account?
Sign up
.


@import services.dao.User
@import shared.SharedMessages
@(allUsers: List[User])(implicit environment: play.api.Environment)
@ssh.mdlImports()
This is the default dialog which is useful for displaying information. The dialog window can be moved, resized and closed with the 'x' icon.
@helper.form(action = routes.SshController.add) {
}
| Name |
|
@for(user <- allUsers){
| @user.name |
|
}
@playscalajs.html.scripts("client")


Match Play. Red trails 0-3 to 5. How should Red play 55?
pips Red=152 White=174
(CorrectAnswer= 0/0, ErrorScore= 0)
For money the correct play would be 20/10(2)*. At this score a gammon would get Red to the Crawford Game with his opponent on an odd score. Therefore. it is worth trying for the gammon with 20/10*, 8/3(2).
The extra 4% of gammons are worth the risk. The safer play is a small error.
The extra 4% of gammons are worth the risk. The safer play is a small error.
1. Cubeful 2-ply 20/10* 8/3(2) Eq.: +0.645 0.599 0.282 0.035 - 0.401 0.093 0.005 2. Cubeful 2-ply 20/10*(2) Eq.: +0.614 (-0.031) 0.620 0.247 0.021 - 0.380 0.081 0.002 3. Cubeful 2-ply 20/15(2) 8/3(2) Eq.: +0.534 (-0.111) 0.596 0.227 0.018 - 0.404 0.107 0.004 4. Cubeful 2-ply 21/16 13/3 8/3 Eq.: +0.520 (-0.125) 0.597 0.217 0.016 - 0.403 0.080 0.002 5. Cubeful 2-ply 21/11 20/10* Eq.: +0.511 (-0.134) 0.578 0.232 0.021 - 0.422 0.102 0.005


Welcome to PyMuscle’s documentation!¶
-
class
pymuscle.
Muscle
(motor_neuron_pool_model, muscle_fibers_model)[source]¶ A user-created
Muscle
object.Used to simulate the input-output relationship between motor neuron excitation and muscle fibers contractile state over time.
Parameters: - motor_neuron_pool_model (
Model
) – The motor neuron pool implementation to use with this muscle. - muscle_fibers_model (
Model
) – The muscle fibers model implementation to use with this muscle. - motor_unit_count – How many motor units comprise this muscle.
Usage:
from pymuscle import (Muscle, PotvinFuglevand2017MotorNeuronPool as Pool, PotvinFuglevand2017MuscleFibers as Fibers) motor_unit_count = 60 muscle = Muscle( Pool(motor_unit_count), Fibers(motor_unit_count), ) excitation = 32.0 force = muscle.step(excitation, 1 / 50.0)
- motor_neuron_pool_model (
-
class
pymuscle.
PotvinFuglevandMuscle
(motor_unit_count, apply_central_fatigue=True, apply_peripheral_fatigue=True, pre_calc_firing_rates=False)[source]¶ A thin wrapper around
Muscle
which pre-selects the Potvin fiber and motor neuron models.
-
class
pymuscle.
Model
(motor_unit_count)[source]¶ Base model class from which other models should inherit
-
class
pymuscle.
PotvinFuglevand2017MotorNeuronPool
(motor_unit_count, max_recruitment_threshold=50, firing_gain=1.0, min_firing_rate=8, max_firing_rate_first_unit=35, max_firing_rate_last_unit=25, pre_calc_firing_rates=False, pre_calc_resolution=0.1, pre_calc_max=70.0, derecruitment_delta=2, adaptation_magnitude=0.67, adaptation_time_constant=22.0, max_duration=20000.0, apply_fatigue=True)[source]¶ Encapsulates the motor neuron portion of the motor unit model.
The name of each parameter as it appears in Potvin, 2017 is in parentheses. If a parameter does not appear in the paper but does appear in the accompanying Matlab code, the variable name from the Matlab code is used in the parentheses.
Parameters: - motor_unit_count (
int
) – Number of motor units in the muscle (n) - max_recruitment_threshold (
int
) – Max excitation required by a motor unit within the pool before firing (RR) - firing_gain (
float
) – The slope of firing rate by excitation above threshold (g) - min_firing_rate (
int
) – The minimum firing rate for a motor neuron above threshold (minR) - max_firing_rate_first_unit (
int
) – Max firing rate for the first motor unit (maxR(1)) - max_firing_rate_last_unit (
int
) – Max firing rate for the last motor unit (maxR(last)) - pre_calc_firing_rates (
bool
) – Whether to build a dict mapping excitation levels to firing rates for each motor neuron. This can speed up simulation at the cost of additional memory. - pre_calc_resolution (
float
) – Step size for excitation levels to pre-calculate (res) - pre_calc_max (
float
) – Highest excitation value to pre-calculate - derecruitment_delta (
int
) – Absolute minimum firing rate = min_firing_rate - derecruitment_delta (d) - adaptation_magnitude (
float
) – Magnitude of adaptation for different levels of excitation.(phi) - adaptation_time_constant (
float
) – Time constant for motor neuron adaptation (tau). Default based on Revill & Fuglevand (2011) - max_duration (
float
) – Longest duration of motor unit activity that will be recorded. The default value should be >> than the time it takes to fatigue all fibers. Helps prevent unbounded values.
Todo
Make pre_calc_max a function of other values as in the matlab code. This will also require changing how we look up values if they are larger than this value.
Usage:
from pymuscle import PotvinFuglevand2017MotorNeuronPool as Pool motor_unit_count = 60 pool = Pool(motor_unit_count) excitation = np.full(motor_unit_count, 10.0) step_size = 1 / 50.0 firing_rates = pool.step(excitation, step_size)
-
step
(motor_pool_input, step_size)[source]¶ Advance the motor neuron pool simulation one step.
Returns firing rates on a per motor neuron basis for the given array of excitations. Takes into account fatigue over time.
Parameters: - excitations – Array of excitation levels to use as input to motor neurons.
- step_size (
float
) – How far to advance time in this step.
Return type: ndarray
- motor_unit_count (
-
class
pymuscle.
PotvinFuglevand2017MuscleFibers
(motor_unit_count, max_twitch_amplitude=100, max_contraction_time=90, contraction_time_range=3, max_recruitment_threshold=50, fatigue_factor_first_unit=0.0125, max_fatigue_rate=0.0225, fatigability_range=180, contraction_time_change_ratio=0.379, apply_fatigue=True)[source]¶ Encapsulates the muscle fibers portions of the motor unit model.
The name of each parameter as it appears in Potvin, 2017 is in parentheses. If a parameter does not appear in the paper but does appear in the Matlab code, the variable name from the Matlab code is in parentheses.
Parameters: - motor_unit_count (
int
) – Number of motor units in the muscle (n) - max_twitch_amplitude (
int
) – Max twitch force within the pool (RP) - max_contraction_time (
int
) – [milliseconds] Maximum contraction time for a motor unit (tL) - contraction_time_range (
int
) – The scale between the fastest contraction time and the slowest (rt)
Fatigue_factor_first_unit: The nominal fatigability of the first motor unit in percent / second
Fatigability_range: The scale between the fatigability of the first motor unit and the last
Contraction_time_change_ratio: For each percent of force lost during fatigue, what percentage should contraction increase? Based on Shields et al (1997)
Todo
The argument naming isn’t consistent. Sometimes we use ‘max’ and other times we use ‘last unit’. Can these be made consistent?
Usage:
from pymuscle import PotvinFuglevand2017MuscleFibers as Fibers motor_unit_count = 60 fibers = Fibers(motor_unit_count) motor_neuron_firing_rates = np.rand(motor_unit_count) * 10.0 step_size = 0.01 force = fibers.step(motor_neuron_firing_rates, step_size)
-
step
(motor_pool_output, step_size=0.1)[source]¶ Advance the muscle fibers simulation one step.
Returns the total instantaneous force produced by all fibers for the given input from the motor neuron pool.
Parameters: - motor_pool_output (
ndarray
) – An array of firing rates calculated by a compatible Pool class. - step_size (
float
) – How far time has advanced in this step.
Return type: - motor_pool_output (
- motor_unit_count (
Implementations of equations used in Hill-Type muscle models
Not all equations for a traditional Hill-Type model are provided here. It is expected that passive elements will be modeled by a physics simulator selected by PyMuscle users.
Also it should be noted that these equations do not take pennetation angle into account (which is common in Hill-type models). Users should check to make sure their physics simulator is handling forces correctly to provide values which vary by angle.