Joe Biden On Violence Against Women: We Have To Keep ‘Punching At It, And Punching At It And Punching At It’
A few people laughed in the audience as he said this.
by Shelby Talcott | The Daily CallerFormer Vice President Joe Biden said that America needs to be “punching” back to combat violence against women during Wednesday’s Democratic debate.
Biden was asked if he would tackle specific issues regarding the #MeToo movement at the beginning of his presidency, if he were to be elected. The former vice president previously sponsored the 1994 Violence Against Women Act (VAWA), which aimed to protect victims of domestic violence.
The presidential candidate responded to the question about assaulting women by using the phrase “punching” repeatedly, apparently not thinking about the implications of using such a word.
“No man has a right to raise a hand to a woman in anger other than in self-defense, and that rarely ever occurs,” Biden said. “So we have to just change the culture, period, and keep punching at it and punching at it and punching at it. No, I really mean it.”
A few people laughed in the audience as he said this.
Biden added that it is important to pass the Violence Against Women Act, which has passed in the House and held up in the Senate. The former Vice President also suggested that America has to “fundamentally change the culture” of how women are treated, noting that it is “everyone’s responsibility.”
“It’s a gigantic issue, and we have to make it clear from the top, from the president on down that we will not tolerate it,” Biden said. “We will not tolerate this culture.”
Alex Jones Confronts Leftist Demons & Trump In Austin
During President Trump’s visit to Austin, Texas, Alex Jones shows up to confront him and is met by leftist demons against free speech.
By the way, overhaul your body’s cellular engine with our fan-favorite DNA Force Plus!


ZPA¶
This package covers the ZPA interface.
- class ZPA¶
A Controller to access Endpoints in the Zscaler Private Access (ZPA) API.
The ZPA object stores the session token and simplifies access to API interfaces within ZPA.
- _customer_id¶
The ZPA tenant ID found in the Administration > Company menu in the ZPA console.
- Type
- __init__(**kw)¶
- property app_segments¶
The interface object for the ZPA Application Segments interface.
- property certificates¶
The interface object for the ZPA Browser Access Certificates interface.
- property cloud_connector_groups¶
The interface object for the ZPA Cloud Connector Groups interface.
- property connector_groups¶
The interface object for the ZPA Connector Groups interface.
- property idp¶
The interface object for the ZPA IDP interface.
- property machine_groups¶
The interface object for the ZPA Machine Groups interface.
- property policies¶
The interface object for the ZPA Policy Sets interface.
- property posture_profiles¶
The interface object for the ZPA Posture Profiles interface.
- property saml_attributes¶
The interface object for the ZPA SAML Attributes interface.
- property scim_attributes¶
The interface object for the ZPA SCIM Attributes interface.
- property scim_groups¶
The interface object for the ZPA SCIM Groups interface.
- property server_groups¶
The interface object for the ZPA Server Groups interface.
- property servers¶
The interface object for the ZPA Application Servers interface.
- property trusted_networks¶
The interface object for the ZPA Trusted Networks interface.


Xiaomi Fish Tank launched, it can be powered by a Power Bank
by Marco LancasterXiaomi Fish Tank launched, it can be powered by a Power Bank
4 (80%) 4 votes
Xiaomi’s portfolio of unusual products has just received a new member – Xiaomi Fish Tank. Yeah, you heard it right, the popular giant of China has just released a fish tank that can fit perfectly at homes and offices. The fish tank comes with a 299 yuan ($43) price tag.
The fish tank is design comes to keep an ecological balance. This way users don’t need to change the water frequently as nitrates and other wastes are removed. Interestingly enough, there’s a compartment at the top where you can raise flowers. Besides this, you don’t need to open the entire upper lid in order to feed the fish. There is an adjustment knob in the side for feeding. It also adjusts the overall oxygen supply. The fish tank incorporates the siphon principle to balance up the fish rearing and keeping the plant watered via water vapor. When the tank stores water, the vapor is sent up to the plant.
Xiaomi’s Fish Tank comes with a friendly design with a one-button solution. The water can be removed automatically with a simple button press, thus removing the cumbersome water changes the process. It also includes a four-stage filtration system, volcanic stone and magnetic ring stone culture nitrifying bacteria.
The design also includes a 360-degree curved glass which ensures there is no viewing dead angle. Last but not least, it has beautiful lights to give a cool looking effect. The Xiaomi Fish Tank has low power consumption and can be powered by a Power Bank.


PRIMAL RUMBLE LTM
Team Rumble meets Save The World in this action-packed 8 vs. 8 Team Deathmatch. Complete with Primal Weapons and Creatures.
PLAY IT NOW0
Unique Players
0
Featured Games
0
Limited Time Modes
0
Games Developed
Our Games
We been featured yo check dis out


The MapCalibration app's aim is to assist satnav-based navigation for maps without GPS coordinates. The main idea is to calibrate the map by setting reference markers on a satellite photo map, in locations easy to identify on both maps. Then, the app computes the map scale. From now on, an user can identify locations on the calibrated map by measuring distances from reference markers. In detail, there are the following types of markers (colors correspond to colors of respective markers):
reference marker - specified by the marker on the photo map or gps coordinates.
reference scale marker - specified by placing a marker on the photo map and giving the distance from the reference pin marker
The scale of the map can be also typed explicitly.
When the scale of the map is known, we can specify points we would like to find in the terrain:
target xy marker - specified as a horizontal and vertical distance from another marker
target 2-line marker - exact measuring of horizontal and vertical distances is not easy outdoors. It is much easier to measure distances between points. A target 2-line marker is specified by giving the distances from any two markers. Moreover, also it must be specified on which side of the line connecting the reference points the intended location is positioned.
Every marker (either reference or target) can be selected as a target for navigation. The app shows the distance and heading to this marker.
The app requires a network connection for showing the map.
The set of all markers currently defined can be saved. loaded
Assume that we are given the following map.
The units we use for measuging distances are relevant only for the scale (proportion of distance on the map and distance in the terrain). When we do not care about the scale, we can use any units (pixels, centimeters, milimeters, inches, etc).
We choose the first reference point at the crossroad (a location easy to identify both on the map and in the sat photo). First we set a marker:
The corresponding point can be then defined:
After setting the first point the displayed map looks as follows:
The point is shown on the map and listed on the list of navigation points.
Now we add a GPS point for establishing the map scale. We choose a corner of a pond by setting a marker and measuring on the map the distance from the reference point defined previously:
First we need to set a marker in the chosen location:
Then type the measured distance:
After adding the point the scale of the map is computed and displayed:
Now, after establishing the map's scale, we want to find a location with respect to the reference points. Let it be one of the turns of a power line.
The lines on the map show the distances measured from two reference points:
koko
A target point is defined with respect to this data:
As we can see, the point is found with the accuracy of just few meters:
My way to MVVM pattern using RxJava, LiveData, Room, Paging with the Android databinding
MVVM is an architectural pattern that was created to simplify user interface programming. Google appears to be encouraging the use of MVVM for data binding. In fact, the Architecture Components of its Data Binding Library are modeled on the MVVM pattern.
<data>
<variable name="vm" type="com.mapcalibration.mvvm.viewmodel.search.SearchViewModel"/>
</data>
<androidx.appcompat.widget.AppCompatImageButton
android:id="@+id/search_button"
android:layout_width="48dp"
android:layout_height="48dp"
android:src="@drawable/ic_search"
android:background="?attr/selectableItemBackgroundBorderless"
android:onClick="@{() -> vm.search()}"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintLeft_toRightOf="@+id/search_edit"/>
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val binding = DataBindingUtil.setContentView<ActivitySearchBinding>(this, R.layout.activity_search)
binding.vm = getViewModel()
binding.setLifecycleOwner(this)
}
<data>
<variable name="item" type="com.mapcalibration.mvvm.data.remote.domain.Repository"/>
<variable name="vm" type="com.mapcalibration.mvvm.viewmodel.search.SearchViewModel"/>
</data>
<androidx.appcompat.widget.AppCompatTextView
android:id="@+id/repository_item_name"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="6dp"
<EMAIL_ADDRESS>app:layout_constraintTop_toTopOf="parent"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"/>
override fun onBindViewHolder(holder: RepositoryViewHolder, position: Int) {
holder.binding.item = items[position]
holder.binding.vm = vm
}
class RepositoryViewHolder(view: View) : RecyclerView.ViewHolder(view) {
val binding: LayoutRepositoryItemBinding = LayoutRepositoryItemBinding.bind(view)
}
DataBinding Declaratively bind observable data to UI elements.
Lifecycle Create a UI that automatically responds to lifecycle events.
LiveData Build data objects that notify views when the underlying database changes.
ViewModel Store UI-related data that isn't destroyed on app rotations. Easily schedule asynchronous tasks for optimal execution.
Room Access your app's SQLite database with in-app objects and compile-time checks.
Paging Makes it easier for you to load data gradually and gracefully within your app's RecyclerView.
Retrofit2 Type-safe HTTP client for Android and Java by Square, Inc.
OkHttp An HTTP+HTTP/2 client for Android and Java applications.
RxJava2 A library for composing asynchronous and event-based programs using observable sequences for the Java VM
RxAndroid RxJava bindings for Android
Copyright 2019 Maciej Szreter
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


When running a function in JavaScript, you may want to have multiple possible results for a given action. For example, you might ask the user to choose a favorite color, and alter the background of the page depending on their answer. To accomplish this change, you could prompt the user to choose either red or green. If the user chooses red, the background is programmed to turn red, else if they choose green the background is programmed to turn green. You can add more else if conditions for other possible results. Else if they don't choose a color recognized by the page, you can tell them their choice was invalid as a fallback option.
$("#branching-button").click(function() {
var color = prompt("Type either 'green' or 'red'!");
if (color === "green") {
$("body").removeClass();
$("body").addClass("green-background")
} else if (color === "red") {
$("body").removeClass();
$("body").addClass("red-background")
} else {
alert("You didn't choose a color! Try again!")
}
});


This section provides a guide for using xml2rfc-gui.
You may then select one or more output formats, either by clicking the check boxes at the top of the application underneath “Outputs”, or by selecting Options > Output formats from the menu.
Finally, press the Convert button to convert the document to the specified formats. If the document was successfully converted without errors, the new documents will be available in the output directory specified in Preferences. See Customization for further information on configurable settings.
In either case, upon reaching an error the conversion process will halt. The Console window will contain verbose information about the nature of these errors, and the XML document will be shown to the user. Any of the errors displayed in the Console contain clickable links, which will jump directly to the line in the XML source document that raised an error. The line will also be highlighted.
The document may then be edited externally and reloaded, OR edited within xml2rfc-gui itself.
The application’s XML view also serves as a lightweight editor. Changes can be made to the current source document at any time by simply editing the text. Note that you must save your changes before converting, either by selecting File > Save Source from the menu, or pressing the cooresponding keyboard shortcut (Ctrl+S or CMD+S)
The application’s primary behavior is customized by going to Options > Preferences, in which the following sections are available:
Conversion
- Output directory: Specify the directory to create converted documents in. Must be writable.
Appearance
- Document text: Controls the font face and size of text in the main document view. Also controls the showing/hiding of line numbers for XML or Text documents.
- Console text: Controls the font face and size of text in the console view.
Cache
- Cache directory: Specify the directory to cache network-accessed document references. Must be writable
- Cache data: Displays the file size of the cache and allows you to erase it.
References
- Locations: A list of colon (semicolon on windows) delimited directories that the application should search in for document references. A blank directory signifies the application to check in the directory of the source document. Note that this list is initially populated from the environment variable $XML_LIBRARY.
- Network citation library: Base URL that the application should search for document references at.
Note that all of these settings may be reverted to their original values at any time by clicking Restore Defaults


Diversity marks latest class of US Rhodes Scholars
by The Associated PressThe latest group of Rhodes Scholars from the U.S. includes the first transgender women selected for the overseas studies.
The Rhodes Trust announced the selections late Saturday after two days of discussions over 236 applicants from 90 different colleges and universities across the country. More than half of the 32 men and women chosen are minorities.
Along with the first transgender woman, this year’s class also includes two non-binary scholars and the first scholar from the University of Connecticut.
The 32 people chosen for the prestigious program will begin at least two years of all-expenses paid study next fall at Oxford University in England along with students from over 60 countries.
The studies undertaken by the scholars include research into how the human brain deals with stress, how to make computer vision more humanlike and the prevalence of sex work among refugees.
The Associated Press


Module: UI
| Relationships | |
| Namespace Children | |
|
Classes:
|
Overview
The UI module contains a number of methods for creating simple UI
elements from a SketchUp Ruby script.
Class Method Summary
-
.add_context_menu_handler {|menu| ... } ⇒ Integer
The add_context_menu_handler method is used to register a block of code with SketchUp that will be called when a context menu is to be displayed.
-
.beep ⇒ nil
The beep method plays a system beep sound.
-
.create_cursor(path, hot_x, hot_y) ⇒ Integer
The create_cursor method is used to create a cursor from an image file at the specified location.
-
.inputbox(prompts, defaults, title) ⇒ Array<String>, false
Creates a dialog box for inputting user information.
-
.inspector_names ⇒ Array<String>
The .inspector_names method is used to returns the names of all the inspectors.
-
.menu(menu_name = "Plugins") ⇒ Sketchup::Menu
The .menu method retrieves a SketchUp’s menu object with a given name.
-
.messagebox(message, type = MB_OK) ⇒ Integer
Creates a dialog box containing static text with a series of buttons for the user to choose from.
-
.model_info_pages ⇒ Array<String>
The model_info_pages method is used to returns the names of all the available model info pages.
-
.openpanel(title, directory, filename) ⇒ String
The .openpanel method is used to display the Open dialog box.
-
.openURL(url) ⇒ Boolean
The .openURL method is used to open the default browser to a URL.
-
.play_sound(filename) ⇒ nil
The play_sound method is used to play a sound file.
-
.preferences_pages ⇒ Array<String>
The preferences_pages method is used to returns the names of all the preferences pages.
-
.refresh_inspectors ⇒ nil
Tells SketchUp to refresh all inspectors such as the Component Browser and the Outliner.
-
.refresh_toolbars ⇒ nil
Tells SketchUp to refresh all floating toolbars.
-
.savepanel(title, directory, filename) ⇒ String
The .savepanel method is used to display the Save dialog box.
-
.scale_factor ⇒ Float
Returns the scaling factor SketchUp uses on high DPI monitors.
-
.select_directory(options = {}) ⇒ String, ...
The .select_directory method is used to display the OS dialog for selecting one or several directories from the file system.
-
.set_cursor(cursor_id) ⇒ Boolean
The .set_cursor method is used to change the cursor to a new cursor with a given cursor id.
-
.set_toolbar_visible(name, visible) ⇒ Boolean
The set_toolbar_visible method is used to set whether a given toolbar is visible.
-
.show_extension_manager ⇒ nil
The
show_extension_manager
method is used to display the Extension Manager dialog. -
.show_inspector(name) ⇒ Boolean
The .show_inspector method is used to display the inspector with the given name.
-
.show_model_info(page_name) ⇒ Boolean
The .show_model_info method is used to display the model info dialog for a specific page.
-
.show_preferences(page_name) ⇒ Boolean
The show_preferences method is used to display a SketchUp preferences dialog.
-
.start_timer(seconds, repeat = false) {|procedure| ... } ⇒ Integer
The start_timer method is used to start a timer.
-
.stop_timer(id) ⇒ nil
The stop_timer method is used to stop a timer based on its id.
-
.toolbar(name) ⇒ UI::Toolbar
The toolbar method is used to get a Ruby toolbar by name.
-
.toolbar_names ⇒ Array<String>
The toolbar_names method is used to return the name of all the available native toolbars (this differs between PC and Mac).
-
.toolbar_visible?(name) ⇒ Boolean
The toolbar_visible? method is used to determine whether a given toolbar is visible.
Class Method Details
.beep ⇒ nil
The beep method plays a system beep sound.
The beep method does not accept any arguments nor return any values.
.create_cursor(path, hot_x, hot_y) ⇒ Integer
The create_cursor method is used to create a cursor from an image file at the specified location. This must be called from within a custom Tool. See the Tool class for a complete example.
Since SketchUp 2016 it is possible to provide vector images for the cursors. SVG format for Windows and PDF format for OS X.
Creates a dialog box for inputting user information. The dialog box contains input fields with static text prompts, optional default values, optional drop down selections, and optional title.
You can also use this method to display drop down lists of options, by passing an optional param.
.inspector_names ⇒ Array<String>
The .inspector_names
method is used to returns the names of all the inspectors. Inspectors are another name for the various floating dialog windows that you can activate from withing SketchUp, such as the Materials window.
.messagebox(message, type = MB_OK) ⇒ Integer
Creates a dialog box containing static text with a series of buttons for the user to choose from.
Valid message box types are:
-
MB_OK
- Contains an OK button. -
MB_OKCANCEL
- Contains OK and Cancel buttons. -
MB_ABORTRETRYIGNORE
- Contains Abort, Retry, and Ignore buttons. -
MB_YESNOCANCEL
- Contains Yes, No, and Cancel buttons. -
MB_YESNO
- Contains Yes and No buttons. -
MB_RETRYCANCEL
- Contains Retry and Cancel buttons. -
MB_MULTILINE
- Contains and OK button.
Return values can be any of following:
-
IDOK
-
IDCANCEL
-
IDABORT
-
IDRETRY
-
IDIGNORE
-
IDYES
-
IDNO
In an MB_MULTILINE
message box, the message is displayed as a multi-line message with scrollbars (as needed). MB_MULTILNE
also allows a third string argument that will be used as the title for the messagebox.
.model_info_pages ⇒ Array<String>
The model_info_pages method is used to returns the names of all the available model info pages. These include UI
windows such as Components, Credits, and Units.
.openpanel(title, directory, filename) ⇒ String
The .openpanel
method is used to display the Open dialog box. The path that is returned can then be used inside code to open a text or image file. See the standard Ruby class File for examples of reading and writing from disk.
.openURL(url) ⇒ Boolean
The .openURL
method is used to open the default browser to a URL.
.play_sound(filename) ⇒ nil
The play_sound method is used to play a sound file. Valid sound files include .wav and .mp3 files on the Mac and .wav files on the PC.
.preferences_pages ⇒ Array<String>
The preferences_pages method is used to returns the names of all the preferences pages. These include windows like Templates.
- SketchUp 2017
-
"Extensions"
page was removed.
.refresh_inspectors ⇒ nil
Tells SketchUp to refresh all inspectors such as the Component Browser and the Outliner. This is useful when you need to manually force a refresh after you’ve made a change to the document via Ruby. Generally, SketchUp will keep these in sync for you, but occasionally it does not, such as when model.start_operation has disabled UI
updates.
.refresh_toolbars ⇒ nil
Tells SketchUp to refresh all floating toolbars. This is useful when you need to manually force a refresh after you’ve made a change to the document via Ruby. Generally, SketchUp will keep these in sync for you, but occasionally it does not, such as when Sketchup::Model#start_operation has disabled UI
updates. This only affects macOS, on Windows the toolbars are always refreshing.
.savepanel(title, directory, filename) ⇒ String
The .savepanel
method is used to display the Save dialog box. The path that is returned can then be used inside code to save out a text or image file. See the standard Ruby class File for examples of reading and writing from disk.
.scale_factor ⇒ Float
SU2017M0 will automatically scale up line width and text size, but will not scale up the points provided to Sketchup::View#draw2d.
Returns the scaling factor SketchUp uses on high DPI monitors. Useful for things like Sketchup::View#draw2d.
.select_directory(options = {}) ⇒ String, ...
The .select_directory
method is used to display the OS dialog for selecting one or several directories from the file system.
.set_cursor(cursor_id) ⇒ Boolean
The .set_cursor
method is used to change the cursor to a new cursor with a given cursor id. See UI.create_cursor and the Tool class for details on creating your own tools with arbitrary cursors.
If you call this while a standard SketchUp tool is active, you will not see your custom cursor, as these tools are constantly setting their own cursors to indicate SketchUp’s state.
.set_toolbar_visible(name, visible) ⇒ Boolean
The set_toolbar_visible method is used to set whether a given toolbar is visible. Note that the toolbars and their names are different on the Mac vs. PC, so be careful and be sure to test when using this method in a cross-platform script.
.show_extension_manager ⇒ nil
The show_extension_manager
method is used to display the Extension Manager dialog.
.show_inspector(name) ⇒ Boolean
The .show_inspector
method is used to display the inspector with the given name. You can get the list of valid inspectors with UI
.inspector_names.
.show_model_info(page_name) ⇒ Boolean
The .show_model_info
method is used to display the model info dialog for a specific page. You can get the list of valid page names with .model_info_pages.
- SketchUp 2014
-
"Classifications"
page was added.
.show_preferences(page_name) ⇒ Boolean
The show_preferences method is used to display a SketchUp preferences dialog. You can get the list of valid dialogs with .preferences_pages.
.start_timer(seconds, repeat = false) {|procedure| ... } ⇒ Integer
The start_timer method is used to start a timer. This is an effective method to create a repeating snippet of code for arbitrary animation.
See this blog post for an detailed example of custom animation using timers: sketchupapi.blogspot.com/2008/10/animate-yo-cheese.html
Note that there is a bug that if you open a modal window in a non-repeating timer the timer will repeat until the window is closed.
.stop_timer(id) ⇒ nil
The stop_timer method is used to stop a timer based on its id.
.toolbar(name) ⇒ UI::Toolbar
The toolbar method is used to get a Ruby toolbar by name. If the toolbar doesn’t exist a new one will be created.
.toolbar_names ⇒ Array<String>
The toolbar_names method is used to return the name of all the available native toolbars (this differs between PC and Mac). These toolbar names do not include Ruby toolbars.
.toolbar_visible?(name) ⇒ Boolean
The toolbar_visible? method is used to determine whether a given toolbar is visible. Note that the toolbars and their names are different on the Mac vs. PC, so be careful and be sure to test when using this method in a cross-platform script.


CineMentality
Seach Movie Reviews
Search Movies
Member Login
(current)
Sign Up
Login Form
Email address
Password
Login
Or sign up
here


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use org.w3c.dom.html | |
| org.apache.html.dom | |
| org.w3c.dom.html |
Classes in org.w3c.dom.html used by org.apache.html.dom| HTMLAnchorElement
|
The anchor element. HTMLAppletElement
|
An embedded Java applet. HTMLAreaElement
|
Client-side image map area definition. HTMLBaseElement
|
Document base URI. HTMLBaseFontElement
|
Base font. HTMLBodyElement
|
The HTML document body. HTMLBRElement
|
Force a line break. HTMLButtonElement
|
Push button. HTMLCollection
|
An HTMLCollection is a list of nodes.HTMLDirectoryElement
|
Directory list. HTMLDivElement
|
Generic block container. HTMLDListElement
|
Definition list. HTMLDocument
|
An HTMLDocument is the root of the HTML hierarchy and holds
the entire content.HTMLDOMImplementation
|
The HTMLDOMImplementation interface extends the
DOMImplementation interface with a method for creating an
HTML document instance.HTMLElement
|
All HTML element interfaces derive from this class. HTMLFieldSetElement
|
Organizes form controls into logical groups. HTMLFontElement
|
Local change to font. HTMLFormElement
|
The FORM element encompasses behavior similar to a collection
and an element.HTMLFrameElement
|
Create a frame. HTMLFrameSetElement
|
Create a grid of frames. HTMLHeadElement
|
Document head information. HTMLHeadingElement
|
For the H1 to H6 elements.HTMLHRElement
|
Create a horizontal rule. HTMLHtmlElement
|
Root of an HTML document. HTMLIFrameElement
|
Inline subwindows. HTMLImageElement
|
Embedded image. HTMLInputElement
|
Form control. HTMLIsIndexElement
|
This element is used for single-line text input. HTMLLabelElement
|
Form field label text. HTMLLegendElement
|
Provides a caption for a FIELDSET grouping.HTMLLIElement
|
List item. HTMLLinkElement
|
The LINK element specifies a link to an external resource,
and defines this document's relationship to that resource (or vice versa).HTMLMapElement
|
Client-side image map. HTMLMenuElement
|
Menu list. HTMLMetaElement
|
This contains generic meta-information about the document. HTMLModElement
|
Notice of modification to part of a document. HTMLObjectElement
|
Generic embedded object. HTMLOListElement
|
Ordered list. HTMLOptGroupElement
|
Group options together in logical subdivisions. HTMLOptionElement
|
A selectable choice. HTMLParagraphElement
|
Paragraphs. HTMLParamElement
|
Parameters fed to the OBJECT element.HTMLPreElement
|
Preformatted text. HTMLQuoteElement
|
For the Q and BLOCKQUOTE elements.HTMLScriptElement
|
Script statements. HTMLSelectElement
|
The select element allows the selection of an option. HTMLStyleElement
|
Style information. HTMLTableCaptionElement
|
Table caption See the CAPTION element definition in HTML 4.0. HTMLTableCellElement
|
The object used to represent the TH and TD
elements.HTMLTableColElement
|
Regroups the COL and COLGROUP elements.HTMLTableElement
|
The create* and delete* methods on the table allow authors to construct and modify tables. HTMLTableRowElement
|
A row in a table. HTMLTableSectionElement
|
The THEAD , TFOOT , and TBODY
elements.HTMLTextAreaElement
|
Multi-line text field. HTMLTitleElement
|
The document title. HTMLUListElement
|
Unordered list. |
Classes in org.w3c.dom.html used by org.w3c.dom.html| HTMLCollection
|
An HTMLCollection is a list of nodes.HTMLDocument
|
An HTMLDocument is the root of the HTML hierarchy and holds
the entire content.HTMLElement
|
All HTML element interfaces derive from this class. HTMLFormElement
|
The FORM element encompasses behavior similar to a collection
and an element.HTMLTableCaptionElement
|
Table caption See the CAPTION element definition in HTML 4.0. HTMLTableSectionElement
|
The THEAD , TFOOT , and TBODY
elements. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


My name is Grant Rotzien and I aspire to be a programmer/entrepreneur in my near future. Listed below are a set of major goals i have created for myself
I have been fascinated by technology since i was young. I have watched countless tech companies rise and fall as i grew up. Many companies have ceased to delve into the concepts that i would like to see carried out. So after binge watching Silicon Valley on HBO for 2 weeks straight, I decided to take it upon myself to turn my ideas into apps!
Listed below is a record of my background; educational, professional, etc.
Below are a list of things i like to do when im not coding
"If your dreams dont scare you they aint big enough"
Over the past week, I have compiled a number of project's with my peers at Epicodus. Listed below are links to their respective repositories.
A webpage made to greet the world in several different languages Using HTML.
A webpage made to say goodbye to the world in different languages Using HTML.
Github repository that reports the progress being made in correcting the flawed HTML code Using HTML.
A webpage made to describe attributes of my Labrador Retreiver Using HTML, and CSS.
A webpage made to further my own understanding of HTML, CSS, and Git through committing mre than one html page to one repository Using HTML, and CSS
Webpage designed to entail all the given amenities of a fictional Resort Using HTML, and CSS.
Webpage made to sarcastically display the best cupcake recipes Using HTML, and CSS
Webpage made to show newfound understanding of the "div" function. Using HTML, and CSS
Blog about Zombies made to furthe demonstrate knowledge of "Divs" Using HTML, and CSS.
Resume template webpage made to showcas knowledge of both "Divs" and Spans Using HTML.
Webpage about the band 'Life of Dillon' made to showcase newfound knowledge of Floats Using HTML, and CSS
HTML webpage that entails what I learned my first week at epicodus. With new Bootstrap styling. Using HTML, and CSS.
Vacation webpage about Antarctica with Bootstrap styling Using HTML, and CSS.
Failed attempt at a recreation of the wikipedia homepage Using HTML, and CSS


Contact
© Laboris id mollit 2010.
Ex reprehenderit enim sunt sint nostrud in
voluptate quis excepteur
01234 000000
Xara Web Designer Ltd
Address line 1
Address line 2
Town/City
County/State
Zip/Postal code
Country
t:
01234 000000
f:
01234 000000
m:
07707 000000
e:
yourname@your domain.com
John Smith
Managing Director
<EMAIL_ADDRESS>Jane Smith
Marketing Director
<EMAIL_ADDRESS>David Doe
Technical Director
daviddoe@yourdomain.com


The quick fix for this inspection converts annotation to the normal form (with attribute name), e.g. @Retention(value=RUNTIME).


{% extends "base.html" %} {% block page_header %}
| Eating Time | {{ foodjournal.eating_time }} |
| Location At The Time | {{ foodjournal.where_i_ate }} |
| What Was Eaten | {{ foodjournal.what_was_eaten }} |
| What Was Drank | {{ foodjournal.what_was_drank }} |
| Mood Before Eating | {{ foodjournal.level_of_mood_before_food }} {{ foodjournal.mood_before_food }} |
| Mood After Eating | {{ foodjournal.level_of_mood_after_food }} {{ foodjournal.mood_after_food }} |


---
products:
new:
limit: {{theme_settings.homepage_new_products_count}}
featured:
limit: {{theme_settings.homepage_featured_products_count}}
top_sellers:
limit: {{theme_settings.homepage_top_products_count}}
carousel: {{theme_settings.homepage_show_carousel}}
blog:
recent_posts:
limit: {{theme_settings.footer_blog_posts_count}}
---
{{#partial "page"}}
{{#if ../theme_settings.home_page_layout '===' 'no-sidenav'}}
{{> components/page/home-page-no-sidenav}}
{{/if}}
{{#if ../theme_settings.home_page_layout '===' 'with-sidenav'}}
{{#if theme_settings.slider_width '!==' 'in-container-floated'}}
{{> components/page/home-page-with-sidenav}}
{{/if}}
{{/if}}
{{#if ../theme_settings.home_page_layout '===' 'with-sidenav'}}
{{#if theme_settings.slider_width '===' 'in-container-floated'}}
{{> components/page/home-page-with-sidenav-float-carousel}}
{{/if}}
{{/if}}
{{/partial}}
{{> layout/home-layout}}


Pat's Salmon Cookies
Home
About Us
Sales
Our Store Locations:
1st and Pike
SeaTac Airport
Seattle Center
Capitol Hill
Alki
Store Hours
6am-8pm
Contact Us
Phone:
555-555-5555
Email:
contact@salmoncookies.com


Login With Facebook
Match with pairs who can teach their language and want to learn yours.
Connect with matched pairs using real-time text and video chat.
Receive Facebook notifications for new matches, messages, and more!


Welcome to WWI Underground!
You must validate your account before you can start using it.Your account validation key is below.
{{accountValidationKey}}


Simple bar chart
This is an example of a simple bar chart with one series.
This is an example of a simple bar chart with one series.
This is an example of a bar chart with two series.
This is an example of a stacked bar chart with two series.
This is an example of a simple line chart with one series.
This is an example of a multi line chart with two series.


David Alan McKelfresh
Unafffiliated
Executive Director, Assessment and Research, Colorado State University
I received my Bachelor's degree in Political Science from Colorado State University in 1974. I received my Master's in College Student Personnel Administration from Colorado State University in 1976. I received my PhD in College Student Personnel Administration from the University of Northern Colorado in 1987.
80525
Prior to 2015 I was on the Board for the Larimer County Food Bank; the Fort Collins City's Affordable Housing Board; on the Board for the Centennial Children's Chorus; and the Board for the Lutheran Campus Ministry.
I donated $50 to Nate Donovan's campaign for the Poudre School Board in Fort Collins, Colorado.
Member of NASPA - Student Affairs Administrators in Higher Education.
In 1969 I entered Colorado State University (CSU) as a Political Science major. My interest in the democratic process was strong then and has continued to grow. After working at CSU for 44 years and nearing retirement in May 2021 I have maintained my strong interest in volunteer public service and citizen participation in the political process. The Colorado Independent Redistricting Commission offers an excellent opportunity to serve the state of Colorado. The commission provides a solution to promote fair redistricting. I have a strong belief that the process of redistricting should be guided by transparency and public input. Additionally, I believe that maps should fairly reflect the will of the voters and that the redistricting commission can improve outcomes and satisfaction across all stakeholders. Protecting the voting rights of persons-of-color, and balancing the preservation of communities of interest with the preservation of county and municipal boundaries is vitally important. Serving on the commission requires the ability to be fair and impartial. For the past 30 years at CSU, I have served as an Equal Opportunity Representative on university search committees, a responsibility that has fairness and impartiality at its core. Additionally, my doctoral dissertation was on ethical decision-making. I taught an Ethics course at the graduate level for over ten years, conducted ethics workshops for the university and community, and presented on ethical decision making at conferences nationally and internationally. The quest for fairness has been a lifetime endeavor. At CSU, I have served on a joint-appointment as both an administrator and faculty member for 37 years. In my faculty role I served as Program Chair for a Master’s program with over 30 faculty which required the ability to promote consensus and agreement on a daily basis. I was able to develop a collegial environment and build consensus on curricular development, course content, and student issues. Effectively promoting agreement involved listening, collaboration, and clear communication. For the past 12 years I have served at the Executive Director of Assessment and Research at CSU. A position that requires analytical skills and the ability to apply logic. The position involves analyzing numerous quantitative and qualitative research and assessment projects, evaluating programs and services, and guiding departments through their five-year program reviews. I have been very successful in using the data to help the institution increase its effectiveness and improve its programs. I also served at the Director of Research on the board of directors of the National Association of Student Personnel Administrators (NASPA), and chaired the Committee on Commissioned Research for the Association of College and University Housing Officers – International (ACUHO-I). In addition to analytical skills and the application of logic, the coin of the realm in all of these positions is trust and credibility. I am currently working half-time and will be fully retiring from CSU at the end of May, 2021. I make the best of every day and look forward to contributing considerable time to the commission. All my best, David A. McKelfresh
(Excerpt from my Statement of Interest) Serving on the commission requires the ability to be fair and impartial. For the past 30 years at Colorado State University I have served as an Equal Opportunity Representative on university search committees, a responsibility that has fairness and impartiality at its core. Additionally, my doctoral dissertation was on ethical decision-making. I taught an Ethics course at the graduate level for over ten years, conducted ethics workshops for the university and community, and presented on ethical decision making at conferences nationally and internationally. The quest for fairness has been a lifetime endeavor. At CSU, I have served on a joint-appointment as both an administrator and faculty member for 37 years. In my faculty role I served as Program Chair for a Master’s program with over 30 faculty which required the ability to promote consensus and agreement on a daily basis. I was able to develop a collegial environment and build consensus on curricular development, course content, and student issues. Effectively promoting agreement involved listening, collaboration, and clear communication.
(Excerpt from my Statement of Interest) For the past 12 years I have served at the Executive Director of Assessment and Research at CSU. A position that requires analytical skills and the ability to apply logic. The position involves analyzing numerous quantitative and qualitative research and assessment projects, evaluating programs and services, and guiding departments through their five-year program reviews. I also served at the Director of Research on the board of directors of the National Association of Student Personnel Administrators (NASPA), and chaired the Commissioned Research Task Force for the Association of College and University Housing Officers – International (ACUHO-I). In addition to analytical skills and the application of logic, the coin of the realm in all of these positions is trust and credibility.
Male


* What's Emotional Intelligence?
Is the ability to recognize, understand, manage and deal with your own and other's emotions.
*How is it different to IQ?
While IQ can be measured by a score comparison with other individuals that have taken the IQ test and are in the same age group's result, EQ is more related to emotion-based problem solving.
* Why is it important?
Measuring the IQ is not the only way to find out if someone will succeed in life as it was believed in the past. Nowadays more companies use EQ tests as part of their hiring process, since researches found that good leaders had higher emotional intelligence.


Sky Sports pundit predicts Arsenal v Southampton
Charlie Nicholas looks ahead to Arsenal's home clash against Southampton on Saturday
by The Sport Review staffCharlie Nicholas is backing Arsenal to claim a dominant 4-1 win over Southampton in their Premier League clash at The Emirates on Saturday afternoon.
The Gunners head into the game looking to return to winning ways after the disappointment of their 2-0 loss to Leicester City last time out.
Arsenal have only won four of their opening 12 games in the Premier League this season and that poor run of form has heaped pressure on Unai Emery.
The north London side are down in sixth place in the table and already eight points behind fourth-placed Manchester City heading into this weekend’s round of games.
Arsenal have only managed won Premier League win in their last five top-flight outings and they will be hoping to claim the three points when they host 19th-placed Southampton on Saturday.
Former Arsenal star Nicholas is not expecting the Gunners to have any problems when they host the Saints at The Emirates this weekend.
Writing in his column for Sky Sports, Nicholas said: “This will have been a banker in the past. Southampton normally don’t get anything at the Emirates in the Premier League.
“By now, the Arsenal players will have returned and Unai Emery will have had some words to say to them. These are two managers under scrutiny.
“Southampton are getting credit after their response to the 9-0 drubbing but they keep getting beat. The goalkeeper and the back three are still vulnerable.
“Alexandre Lacazette was not on international duty and Pierre-Emerick Aubameyang has been a bit quiet recently, so it is time for Arsenal to get back to winning ways. They are sixth in table and have been awful.
“Chelsea are going to Manchester City, which could bring back a little belief once more that the top four is achievable. These are the games you are expected to win and Arsenal will win.”
Arsenal are aiming to try and break back into the top four this season after they finished fifth and without a trophy in Emery’s first campaign in charge last season.


Text Mining Visualization
Select document
Guidance
Hashedcubes
Auswählen
Select analysis
Wordcount
Sentence Length
Punctuation
Stopwords
Sunburst
Tree
Bubble Chart


Who cares about the clouds when we're together? Just sing a song and bring the sunny weather.
Dale Evans


QoE Experiment
QoE Experiment
Please fill the following questionnaire
Gender
Male
Female
Other
What is your age group
18-21
21-29
30-39
40-49
50-59
Eye vision
Normal or corrected vision
Other
Education
High School
Bachelor Degree
Graduate Degree
Other
Utilization of PC
None
Basic
Middle
Good
Main purpose of using web maps
Personal
Perfessional/Business
Frequency of using web maps:
Daily
Weekly
Less than Monthly


Anytime you need to display a piece of content—like an image with an optional caption, consider using a

.
Use the included .figure
, .figure-img
and .figure-caption
classes to provide some baseline styles for the HTML5

and

elements. Images in figures have no explicit size, so be sure to add the .img-fluid
class to your
to make it responsive.

A caption for the above image.

Aligning the figure’s caption is easy with our text utilities.

A caption for the above image.


#
PSYOPS refer to psychological operations which are used to communicate specifically selected information in order to influence people.
PSYOPS are designed to influence emotions, reasoning, and the behavior of individuals, groups, or organizations.
These psychological operations are not only conducted during times of war, but are strategically conveyed during times of peace as well.
The PSYOPS that occur during peacetime often present themselves as predictive programming, disinformation formulas, engineered events, and may even use Neuro Linguistic Programming.
This ultimately keeps us pitted against each other, rallying behind unnecessary wars, and blind to the Truth. These are a mega reason we can’t have nice things.
Please Join Us For Episode 18 of The Peace Academy Tonight 8-9 PM EST!
You can listen live at the mspwaves website- http://mspwaves.com/home/listen
You can listen on twitch- https://www.twitch.tv/mspwaves
You can join broadcast hosts in a special chat room on the MSP Discord Channel: https://discord.gg/kNxM7T6
You can check out http://mspwaves.com for more information
This page is synchronized from the post: ‘The Peace Academy with @aggroed and @isaria // Episode 18 Tonight! // MSP-Waves Radio (1hr from now!)’


Real Estate
Loft design
Interior design
Appartments
World living rooms
Holidays
Holidays rentals
Bali rentals
Etapes de France
British Castles
Photography
Street portraits
HDR only
Animals
Gallery web application
{{ item.title|words:10 }}
Created by :
<EMAIL_ADDRESS>Github Project


Inside Koval's 3D Grapher
Koval's 3D Grapher is an interactive function plotter in three dimensions. Here's an example plot:
And another:
Koval's 3D Grapher is a conglomerate of various mathematical identities and algorithms and a large chunk of good 'ol hacking. What follows is a summary of some of the main components, their challenges, and how they evolved over time.
Plotting Points
A surface \(f(x,y)\) is made up of an infinite number of points. A sphere is made by drawing every point that is a certain distance from another point. An sinusoidal surface is made up of an infinite number of points that form sine and cosine cross sections.
Because a function is a relation between three variables (\(x\), \(y\) and \(z\)), all surfaces are guaranteed to be made up of points that have a distinct value for these variables. Furthermore, these points satisfy the given equation: \[g(x,y,z)=0\] For the unit sphere, the euclidean distance from every point to the origin is one, so \(g(x,y,z)=\sqrt{x^2+y^2+z^2}-1=0\). For a sinusoid, we have \(g(x,y,z)=\sin{x}+\sin{y}-z=0\)
If we were to try to find these points, we might naively attempt to iterate through a bunch of \((x,y,z)\) points and see if any of them fulfill our equation. Perhaps we would try points in an orderly manner, and perhaps we would even gauge how "far" a point is from the surface by the magnitude of \(g(x,y,z)\). This works, but it is slow. In order to transverse a region in three dimensions, we must iterate through \(x\), \(y\), and \(z\), which is \(O(n^3)\).
Additionally, actually finding the surface can be difficult, since \(g(x,y,z)\) may get arbitrarily close to zero without actually passing through zero, leading to misplaced points. Consider the relation \( g(x,y,z)=\left( \frac{x}{z} \right) ^2 + \left( \frac{y}{z} \right) ^2 \). Except at \(x=0\) and \(y=0\), \(g\) is never going to equal zero, despite getting arbitrarily close as \(z\to \pm \infty\). How do you decide which points are "close enough" to 0?
This is why, if you've ever worked with 3D functions, you have seen functions in the form \(z=f(x,y)\), \(y=f(x,z)\) or \(x=f(y,z)\). Instead of testing every possible \((x,y,z)\) point (which is of course impossible), we iterate through two variables and solve for the third. Consider our sinusoidal surface. Instead of solving for all our variables in the equation \(\sin{x}+\sin{y}-z=0\), we solve for \(z\) using \(z=\sin{x}+\sin{y}\). We still cannot guarantee that we are going to capture all of the points on the surface (there are an infinite number of them), but we can at least guarantee that all the points will lie exactly on the surface.
The algorithm to plot points on a surface is relatively simple. Pick an orderly selection of two of the variables, solve for the third, and add the point to a list.
From Points to a Surface
Points are great. They are the basis of our surface. But we can only plot so many points. Eventually, we are going to have to stop making points and start connecting them. To do this, we need to interpolate between points â€“ make our best guess as to where the surface should be. The question is, which interpolation method is best? Which gives the viewer the impression that the entire surface is plotted instead of a selection of points?
You've probably guessed that the straight line is the best bet. There are several reasons for this. First of all, lines are quite easy to work with from a graphics perspective. They are computationally cheap and require the least effort to implement. Second, it is much easier to shade a polygon than an arbitrary 2D shape. Since straight lines project onto planes in straight lines, polygons can be colored in 2D on the projected surface, unlike curves. I'll get into this more in Part II. Finally, all surfaces are locally planar, which is the basis of most of 3D calculus. Since we are treating our points as infinitesimal changes in our surface, it makes sense to connect them as if they were actually infinitesimally far away â€“ with straight lines.
Straight line connections make life much easier. However, there still needs to be a way of drawing all these connections in a way that doesn't draw some twice. For reasons that will become apparent in the "Cleaning Up the Mess" section, I chose to use a doubly linked 2D array. In this system, each point is linked to its neighbors, one to the right and left, one above and one below. That way, we can know what connections exist come drawing time.
It is important to note that the words "above," "below," "right," and "left" have little physical meaning. Especially when we begin to parameterize functions, these connections will have little correlation in the \(xyz\) coordinate world. Think of them as connections to the point plotted before it, the point plotted after it, and the points plotted a row ahead and behind.
This system makes drawing very easy. For every point, draw two lines â€“ one from the point to the point below it and one to the point on the right. This guarantees that no line will be drawn twice, unlike a polygon system.
Using this system, we can now plot a rudimentary surface.
Cleaning Up the Mess
At this point is may seem like the surface is complete. Unfortunately, a surface is often more complex than this â€“ literally. Consider the function \[z=\sqrt{25-x^2-y^2}\] You may recognize this as a half sphere. Perhaps you've done some algebra in your head and noticed that this is nearly equivalent to \(x^2+y^2+z^2=25\). The only difference (and what makes it a half sphere) is that the square root function only returns positive values, so \(z>0\).
See what happens when \(x=5\) and \(y=5\): \[z=\sqrt{25-5^2-5^2}\] \[z=\sqrt{-25}\] \[z=5i\] \(z\) is a complex number. Complex numbers don't fit into the standard Cartesian 3D coordinate system, so \((5,5,5i)\) should not be shown, even though it exists.
This isn't that much of a problem until you realize what happens to the surface after all the complex points are taken out:
What results is points that are near the edge of the surface â€“ that is, the boundary between real and nonreal points â€“ but not quite there. Because the points are created in a square grid, the points are almost never going to be on a boundary that is any sort of curve, like a circle. This means that there is going to be jagged edges, even with a high number of points.
A solution takes advantage of the fact that the points are linked to their neighbors. Consider a point that is part of the jagged edge seen in the previous picture. One of its neighbors is complex and not shone, but it still exists. Therefore, the real boundary between real and nonreal points exists somewhere between these two points.
Thus we need to implement a search algorithm. Instead of an array of values, however, there is an interval of infinite booleans â€“ real or nonreal. Additionally, it is an ordered list since the surface transitions to imaginary then stays there. This is the perfect task for a binary search.
A binary search is also a great time to use recursion. It is essential the reduction of an interval in which the boundary lies, so the process remains the same no matter the size of the interval. In fact, here's the exact code in Koval's 3D Grapher:
function findParametricEdge(realP, nonRealP, xFunc, yFunc, zFunc, iterations){
//when we have completed the necessary amount of iterations,
// return the real end of the interval containing the boundary
if(iterations === 0){
return realP;
}
//find the midpoint of realP and nonRealP in terms of parameterized variables
var u = (realP.u + nonRealP.u)/2;
var v = (realP.v + nonRealP.v)/2;
var scope = {
u:u,
v:v,
x:null,
y:null,
z:null
}
//set any animation variables
for(var j = 0; j < animationVars.length; j++){
scope[animationVars[j].name] = animationVars[j].value;
}
//evaluate function at new point (twice to account for function like x = u, y = x, z = y)
xFunc.eval(scope);
yFunc.eval(scope);
zFunc.eval(scope);
xFunc.eval(scope);
yFunc.eval(scope);
zFunc.eval(scope);
//create new point containing xyz and uv coordinates for midppoint
var inBetween = {x:getRealPart(scope.x),y:getRealPart(scope.y),z:getRealPart(scope.z)};
makeFiniteIfInfinate(inBetween)
//domain stretching for non-cubic domains
inBetween.x = spreadCoord(inBetween.x, domain.x.min, domain.x.max, domain.x.spread);
inBetween.y = spreadCoord(inBetween.y, domain.y.min, domain.y.max, domain.y.spread);
inBetween.z = spreadCoord(inBetween.z, domain.z.min, domain.z.max, domain.z.spread);
inBetween.u = u;
inBetween.v = v;
//return new interval
if(isNonReal(inBetween)){
return findParametricEdge(realP, inBetween, xFunc, yFunc, zFunc, iterations - 1);
}else{
return findParametricEdge(inBetween, nonRealP, xFunc, yFunc, zFunc, iterations - 1);
}
}
You'll find out in a later section why everything is defined in terms of \(u\) and \(v\), that is, parameterized. For now we'll stick with the edge detection.
If you run this algorithm on every interval containing both real and imaginary points, then the surface begins to look much more organic â€“ less blocky. Take a look at the same half sphere as a more complete surface:
This is much improved. Now the edge of the surface is clearly seen and most importantly smooth. There is just one thing wrong: loose ends. If you look closely enough you can see that the lines extending to the boundary have only one connection, their base point. This is a large problem when coloring, since coloring depends on polygons to fill in. Without some sort of loop in lines (that is what a polygon is, after all), there is no polygon possible, and so no coloring. What we need is a way to connect all these ends into a cohesive surface boundary, a line that allows polygons to be formed between each end and its neighbor.
To this end, it turns out that simplicity is best. When first mulling over this problem, you might be tempted to try something fancy. One idea is to propagate back from all the loose ends concurrently, traversing edges to extend a loose end "circle" in all directions. When circles from two ends overlap, we connect them.
This is great, but also fiendishly complicated. Also, there are all sorts of edge cases to be worried about. How do you make sure that an end is on the same side of a surface as another end?
In the end, I settled for a shortest distance path algorithm. It proceeds as follows:
- Make a list of all the ends. This is easily done while plotting.
- Start with the first end.
- Find the (unused) end closest in Euclidean distance to this end.
- Connect these two ends.
- Repeat steps 3 - 4 until there are no ends left, or the distance between ends is prohibitively far, indicating a new "end loop."
And finally, we have our completed surface, ready for coloring.


|
|
def | __init__ |
| |
|
def | cpu |
| |
|
def | mutable_cpu |
| |
|
def | clear_cpu |
| |
|
def | has_cpu |
| |
|
def | memory |
| |
|
def | mutable_memory |
| |
|
def | clear_memory |
| |
|
def | has_memory |
| |
|
def | MergeFrom |
| |
|
def | Equals |
| |
|
def | IsInitialized |
| |
|
def | ByteSize |
| |
|
def | ByteSizePartial |
| |
|
def | Clear |
| |
|
def | OutputUnchecked |
| |
|
def | OutputPartial |
| |
|
def | TryMerge |
| |
|
def | __str__ |
| |
|
|
| lazy_init_lock_ |
| |
|
| has_cpu_ |
| |
|
| has_memory_ |
| |
|
|
int | has_cpu_ = 0 |
| |
|
| cpu_ = None |
| |
|
int | has_memory_ = 0 |
| |
|
| memory_ = None |
| |
|
int | kcpu = 1 |
| |
|
int | kmemory = 2 |
| |
The documentation for this class was generated from the following file:
- code/googleappengine-read-only/python/google/appengine/api/system/system_service_pb.py


To get started with MNE, visit the installation instructions for the MNE and MNE-C:
There is much more beyond these general categories such as:
What you’re not supposed to do with MNE:
MNE started as tool written in C by Matti Hämäläinen while at MGH in Boston.
The MNE tools are based on the FIF file format from Neuromag. However, MNE can read native CTF, BTI/4D, KIT and various EEG formats (see IO functions).
If you have been using MNE-C, there is no need to convert your fif files to a new system or database – MNE works nicely with the historical fif files.


- learning Portuguese, 3 times a week during lunch time, 1h30 each
- building a vocabulary database, from new words learned while reading fiction
- practicing and learning the new vocabulary, 1 to 2h before writing sessions
- writing (very) short fiction, almost daily, for sleeplessmind.info
- reading fiction and non-fiction
- managing the Toastmasters meetings of the Macau PAG Toastmasters club as VP of Education
- dealing with Government (immigration, tribunals) regarding my Macau residency issue


fudge.processing.resonances package¶
Subpackages¶
Submodules¶
fudge.processing.resonances.getCoulombWavefunctions module¶
-
fudge.processing.resonances.getCoulombWavefunctions.
coulombNormalizationFactor
(L, eta)[source]¶ Coulomb wavefunction normalization factor (see DLMF Eq. 33.2.5 or Abramowitz & Stegun Eq. 14.1.7),
Because we’re working with numpy arrays of (for parallelization ala’ Caleb’s tricks), the logic of numpy masked arrays is at work here to handle different regimes of eta.
Parameters: - L (int) – the L to evaluate at
- eta (numpy.array(type=float)) – array of values
Returns: array of normalizations
Return type: numpy.array(type=float)
-
fudge.processing.resonances.getCoulombWavefunctions.
coulombPenetrationFactor
(L, rho, eta)[source]¶ Compute the Coulomb penetrability, , where
Because we’re working with numpy arrays of (for parallelization ala’ Caleb’s tricks), the logic of numpy masked arrays is at work here to handle different regimes of eta.
Here we use an external subroutine coulfg2 from Thompson et al, converted to c and wrapped
Parameters: - L (int) – the L to evaluate at
- rho (numpy.array(type=float)) – array of values
- eta (numpy.array(type=float)) – array of values
Returns: array of penetrabilities
Return type: numpy.array(type=float)
-
fudge.processing.resonances.getCoulombWavefunctions.
coulombPhi
(L, rho, eta)[source]¶ Compute the Coulomb phase, ,
Because we’re working with numpy arrays of (for parallelization ala’ Caleb’s tricks), the logic of numpy masked arrays is at work here to handle different regimes of eta.
Here we use an external subroutine ‘coulfg2’ from Thompson et al, converted to c and wrapped
Parameters: - L (int) – the L to evaluate at
- rho (numpy.array(type=float)) – array of values
- eta (numpy.array(type=float)) – array of values
Returns: numpy.array(type=float) of phases
-
fudge.processing.resonances.getCoulombWavefunctions.
coulombShiftFactor
(L, rho, eta)[source]¶ Compute the Coulomb shift, , where
Because we’re working with numpy arrays of (for parallelization ala’ Caleb’s tricks), the logic of numpy masked arrays is at work here to handle different regimes of eta.
Here we use an external subroutine ‘coulfg2’ from Thompson et al, converted to c and wrapped
Parameters: - L (int) – the L to evaluate at
- rho (numpy.array(type=float)) – array of values
- eta (numpy.array(type=float)) – array of values
Returns: array of shifts
Return type: numpy.array(type=float)
fudge.processing.resonances.getScatteringMatrices module¶
fudge.processing.resonances.reconstructResonances module¶
reconstruct resonance region cmattoon, 12/1/2010
See ENDF-102 (endf documentation) appendix D for equations
Basic usage:¶
if x is a reactionSuite instance,:
>>x.reconstructResonances(tolerance=0.01)This reconstructs all resolved/unresolved resonance sections. In each section, the results are accurate under linear interpolation to tolerance of 1% or better. Sections are summed together and then added to the appropriate background cross sections to form new pointwise, lin-lin cross sections that are stored in the appropriate reaction inside reactionSuite x.
Alternate uses:¶
You can skip the final step (adding background cross sections) and just get the resonance parameter contribution to the cross section by doing:
>>xsecs = reconstructResonances.reconstructResonances(x, tolerance=0.01)Here,:
* xsecs = dictionary containing cross sections: {'total':XYs, 'elastic':XYs, ...}each cross section is an XYs class instance, containing data and also axes with units
Another option would be to only reconstruct a single section:
>> resCls = reconstructResonances.RMcrossSection(x, energyUnit='eV') # for Reich_Moore >> energy_grid = s.generateEnergyGrid() >> crossSections = s.getCrossSection( energy_grid ) # the input to getCrossSection is the energy (or list of energies) in self.energyUnit # crossSections are returned as a dictionary {'total':,'elastic':,'capture':,'fission':,} # improve grid to desired tolerance for linear interpolation: >> new_energy_grid, new_crossSections, messages = s.refineInterpolation(energy_grid, crossSections, tolerance=0.01)
-
class
fudge.processing.resonances.reconstructResonances.
ChannelDesignator
(l, J, reaction, index, s, gfact=None, particleA=None, particleB=None, Xi=0.0, isElastic=None, channelClass=None, useRelativistic=False, eliminated=False)[source]¶ Bases:
object
-
J
¶
-
Xi
¶
-
channelClass
¶
-
eliminated
¶
-
gfact
¶
-
index
¶
-
isElastic
¶
-
l
¶
-
particleA
¶
-
particleB
¶
-
reaction
¶
-
s
¶
-
useRelativistic
¶
-
-
class
fudge.processing.resonances.reconstructResonances.
MLBWcrossSection
(reactionSuite, sectionIndex=None, enableAngDists=False, verbose=True, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.RRBaseClass
Given a resonance region in MLBW format, create a class with all data required to reconstruct
Only the elastic channel differs from SLBW
-
getChannelConstantsBc
()[source]¶ For ENDF’s MLBW, should be where is the channel angular momentum and is the resonances index for the channel
-
getScatteringMatrixU
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶ Compute the scattering matrix. We could have used the generic U function in the base class, but Froehner has “simplifications” that we took advantage of here (that and I don’t know what the R matrix is exactly in the case of MLBW).
-
-
class
fudge.processing.resonances.reconstructResonances.
RMatrixLimitedcrossSection
(reactionSuite, sectionIndex=None, enableAngDists=False, verbose=True, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.RRBaseClass
extended Reich_Moore (LRF=7 in ENDF) Here, resonances are sorted primarily by J: within each ‘spin group’, total J is conserved One or more competitive channels may be used in this case. Also, each resonance may have contributions from multiple l-waves
-
eta
(Ex, pA, pB)[source]¶ eta, the Sommerfeld parameter, given by
for competitive channels with 2 charged particles, parameter eta is used to find penetrability. eta is given in eq D.79 of ENDF manual and $e^2$ is the fine structure constant $lpha$ and $m_{red}$ is the reduced mass. eta is dimensionless.
Parameters: - Ex – The incident energy
- pA – xParticle A
- pB – xParticle B
Returns: the Sommerfeld parameter [dimensionless]
-
getChannelConstantsBc
()[source]¶ For ENDF’s Reich-Moore, should be where is the channel angular momentum, but the ENDF manual says nothing about it.
There is a per-channel parameter BCH that we will interpret as
-
getEiPhis
(Ein, useTabulatedScatteringRadius=None, enableExtraCoulombPhase=False)[source]¶ The phase factor for the collision matrix,
Parameters: - Ein (numpy.array(type=float)) –
- useTabulatedScatteringRadius (bool) –
- enableExtraCoulombPhase (bool) –
Returns: Return type:
-
getLMax
(maxLmax=10)[source]¶ LMax is determined by the behavior of the Blatt-Biedenharn Zbar coefficients. Inside each one, there is a Racah coefficient and a Clebsh-Gordon coefficient. The CG coefficient looks like this:
( l1 l2 L ) ( 0 0 0 )So, this means two things. First, the CG coeff (and hence Zbar) will be zero if l1+l2+L=odd. Second, the maximum value of L will be l1max+l2max. Hence, Lmax=2*lmax.
-
getRMatrix
(Ein)[source]¶ The R matrix in the Reich-Moore approximation is
Parameters: Ein (numpy.array(type=float)) – Returns: Return type:
-
getScatteringMatrixT
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶ Parameters: - Ein (numpy.array(type=float)) –
- useTabulatedScatteringRadius (bool) –
- enableExtraCoulombPhase (bool) –
Returns: Return type:
-
k_competitive
(Ex, pA, pB)[source]¶ Calculate k for any 2-body output channel.
Note that if pA and pB are target and neutron, this reduces to self.k(E) as defined above in the resonanceReconstructionBaseClass
Parameters: - Ex – incident energy - Xi (Xi is the lab frame reaction threshold) in eV
- pA – xParticle A
- pB – xParticle B
Returns: k in b**-1/2
-
resetResonanceParametersByChannel
(multipleSScheme='ENDF', useReichMooreApproximation=False, Ein=None)[source]¶
-
rho
(Ein, c)[source]¶ Compute , using the true scattering radius. ENDF uses it for calculating shift and penetrabilities.
Parameters: - Ein – incident energy in the lab frame (shifted by a threshold, if appropriate)
- c – the channel designator
Returns: the value of rho (dimensionless)
-
rhohat
(Ein, c)[source]¶ Compute , using the effective scattering radius ENDF uses it for calculating the phase (but in truth, there should be no effective scattering radius). (Caleb uses self.k below, but I think it should be self.k_competitive for the sake of consistency)
Parameters: - Ein – incident energy in the lab frame (shifted by a threshold, if appropriate)
- c – the channel designator
Returns: the value of rho (dimensionless)
-
setResonanceParametersByChannel
(multipleSScheme='ENDF', useReichMooreApproximation=False, Ein=None, warnOnly=False)[source]¶ Reorganize member data into channels :param multipleSScheme: ignored, kept so has same signature as overridden function :param useReichMooreApproximation: ignored, kept so has same signature as overridden function :return:
-
-
class
fudge.processing.resonances.reconstructResonances.
RMcrossSection
(reactionSuite, sectionIndex=None, enableAngDists=False, verbose=False, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.RRBaseClass
simplified Reich_Moore (LRF=3 in ENDF) More complex than Breit-Wigner approximations, but we can still use same __init__
-
getChannelConstantsBc
()[source]¶ For ENDF’s Reich-Moore, should be
- ..math::
- B_c = -ell
where $ell$ is the channel angular momentum
what is not clearly stated in the ENDF manual is that Bc = 0 for this case
-
-
class
fudge.processing.resonances.reconstructResonances.
RRBaseClass
(reactionSuite, sectionIndex=None, lowerBound=None, upperBound=None, RR=None, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.resonanceReconstructionBaseClass
-
generateEnergyGrid
()[source]¶ Create an initial energy grid by merging a rough mesh for the entire region (~10 points / decade) with a denser grid around each resonance. For the denser grid, multiply the total resonance width by the ‘resonancePos’ array defined below.
-
getAPByChannel
(c, trueOrEffective='true')[source]¶ get the channel radius, rho. If L is specified try to get L-dependent value
-
getAverageQuantities
(resonancesPerBin=10, computeUncertainty=False)[source]¶ Computes average widths and level spacings from the set of resonance parameters in self, on a per-channel basis
The averages are computed in equal lethargy bins starting at the lowest resonance energy in a sequence up to the upperBound of the resonance region. I tried to keep on average 10 resonances/logrithmic bin so I can get a reasonable average.
Parameters: - resonancesPerBin – the number of resonances per logrithmic bin to aim for, on average
- computeUncertainty – toggle the calculation of the uncertainty of the quantities
Returns: a dictionary of results, sorted by channel
-
getBackgroundRMatrix
(Ein, Emin, Emax, gamWidth, pole_strength, Rinf=None)[source]¶ Froehner’s background R matrix. This could be vectorized for speed. Not sure if it would be useful though.
-
getEiPhis
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶ The phase factor for the collision matrix:
- ..math::
- Omega_c = e^{-
arphi_c}
-
getL0Matrix
(Ein)[source]¶ Get the L0 matrix of Froehner:
- ..math::
- {f L^0}_{cc’} = delta_{cc’} (L_c-B_c)
where
- ..math::
- L_c = S_c + i P_c
-
getLMax
(maxLmax=10)[source]¶ LMax is determined by the behavior of the Blatt-Biedenharn Zbar coefficients. Inside each one, there is a Racah coefficient and a Clebsh-Gordon coefficient. The CG coefficient looks like this:
( l1 l2 L ) ( 0 0 0 )So, this means two things. First, the CG coeff (and hence Zbar) will be zero if l1+l2+L=odd. Second, the maximum value of L will be l1max+l2max. Hence, Lmax=2*lmax.
-
getPoleStrength
(computeUncertainty=False)[source]¶ Computes the neutron pole strength from the transmission coefficients
- ..math::
- s_c(E) =
ho_c(E)overline{Gamma_c}/2P_c = T_c(E)/4pi P_c
param computeUncertainty: return:
-
getPorterThomasFitToWidths
(Emin=0.0, Emax=None, verbose=False)[source]¶ Perform a channel-by-channel fit of the histogram of widths to a Porter-Thomas distribution.
Parameters: verbose – Returns:
-
getReducedWidths
(channel, Emin=None, Emax=None)[source]¶ Convert the list of widths to reduced widths:
redWidth = width/2*penetrabilityParameters: - widthList –
- channel –
Returns:
-
getScatteringLength
()[source]¶ Compute R’ in b**1/2, should be close to AP
The potential scattering cross section sigPot = 4 Pi (R’)^2, so we compute the potential scattering cross section at E=1e-5 eV :return:
-
getScatteringMatrixT
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶
-
getScatteringMatrixU
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶ Compute the scattering matrix using
-
getTransmissionCoefficientsFromSumRule
(resonancesPerBin=10, computeUncertainty=False)[source]¶ - Use Moldauer’s sum rule to extract the transmission coefficients directly from the RRR tables
- P.A. Moldauer Phys. Rev. Lett. 19, 1047-1048 (1967)
Parameters: computeUncertainty – toggle the calculation of the uncertainty of the transmission coefficients Returns: a dictionary of results, sorted by channel
-
getWMatrix
(Ein)[source]¶ Get the W matrix for use in computing U. W is:
- ..math::
- {f W} = {f I} + 2i{f X}
-
getXMatrix
(Ein)[source]¶ Get the X matrix for use in computing W. X is:
- ..math::
- {f X}_{cc’} = P^{-1/2}_c ( ( {f I} - {f R}{f L^0} )^{-1}{f R} )_{cc’} P_{c’}^{-1/2}delta_{JJ’}
-
resetResonanceParametersByChannel
(multipleSScheme='ENDF', useReichMooreApproximation=False, Ein=None)[source]¶
-
-
fudge.processing.resonances.reconstructResonances.
RoundToSigFigs
(x, sigfigs)[source]¶ Rounds the value(s) in x to the number of significant figures in sigfigs.
Restrictions: sigfigs must be an integer type and store a positive value. x must be a real value or an array like object containing only real values.
-
class
fudge.processing.resonances.reconstructResonances.
SLBWcrossSection
(reactionSuite, sectionIndex=None, enableAngDists=False, verbose=True, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.RRBaseClass
given a resonance region in SLBW format, create a class with all data required to reconstruct
Note, the resonances in the SLBW format each correspond to different “levels” and so do not interfere. This is unlike all of the other RRR formats. So, while one resonance energy and one width go with one channel and all the channels associated with one resonance energy go together to make one reaction, the reactions for each resonance are added incoherently (no interference effects at all).
-
getScatteringLength
()[source]¶ Compute R’ in b**1/2, should be close to AP
The potential scattering cross section sigPot = 4 Pi (R’)^2, so we compute the potential scattering cross section at E=1e-5 eV :return:
-
getScatteringMatrixU
(Ein, useTabulatedScatteringRadius=True, enableExtraCoulombPhase=False)[source]¶ Compute the scattering matrix
Note, unlike the getScatteringMatrixU() function in other resonance classes, the fact that different resonances are entirely different reactions means that the channelDicts have to have an additional layer of sorting that corresponds to the SLBW “level”.
-
setResonanceParametersByChannel
(multipleSScheme='ENDF', useReichMooreApproximation=False, Ein=None, warnOnly=False)[source]¶ Reorganize member data into channels (relies heavily on groundwork in sortLandJ).
Note, unlike the getResonanceParametersByChannel() function in MLBW, RM or RML, the fact that different resonances are entirely different reactions means that the channelDicts have to have an additional layer of sorting that corresponds to the SLBW “level”.
-
-
class
fudge.processing.resonances.reconstructResonances.
URRPDFTable
(*args, **kwds)[source]¶ Bases:
collections.OrderedDict
Lightweight class for storage and IO of URR PDF’s
Test it as follows:
>>> import xs_pdf as xp >>> import numpy as np >>> u=xp.URRPDFTable() >>> u.eBins=xp.equal_bins(2,0.,4.) >>> u.xsBins=xp.equal_bins(3,1.,1.5) >>> u['capture']=np.zeros(shape=(2,3)) >>> u['capture'][0,0]=1. >>> u['capture'][1,2]=2. >>> print(u) {"eBins": "[ 0. 2. 4.]", "urrPdf": {"capture": "[[ 1. 0. 0.]
- [ 0. 0. 2.]]”}, “xsBins”: “[ 1. 1.16666667 1.33333333 1.5 ]”}
>>> u.save('junk.txt') >>> v=xp.URRPDFTable() >>> v.load('junk.txt') >>> print(v) {"eBins": "[ 0. 2. 4.]", "urrPdf": {"capture": "[[ 1. 0. 0.]
[ 0. 0. 2.]]”}, “xsBins”: “[ 1. 1.16666667 1.33333333 1.5 ]”}
-
Emax
¶
-
Emin
¶
-
NE
¶
-
NXS
¶
-
XSmax
¶
-
XSmin
¶
-
eBinCenters
¶
-
eBinWidths
¶
-
xsBinCenters
¶
-
xsBinWidths
¶
-
class
fudge.processing.resonances.reconstructResonances.
URRcrossSection
(reactionSuite, verbose=True, **kw)[source]¶ Bases:
fudge.processing.resonances.reconstructResonances.resonanceReconstructionBaseClass
-
generateEnergyGrid
(interpolateWidths=False)[source]¶ Get the energy grid for reconstructing unresolved resonances. Usually this is just the energy grid chosen by the evaluator for storing energy-dependent widths.
Now, ENDF says to interpolate on the reconstructed average cross section.  Better is to interpolate on the model inputs (the average widths in the case of URR) and refine the reconstructed cross section to the desired accuracy. This is what the interpolateWidths flag controls.
Parameters: interpolateWidths – if True, interpolate the average widths Returns: a tuple containing the grid and the interpolate flag
-
getCrossSection
(interpolateWidths=False)[source]¶ Get unresolved region cross section for each incident energy in E. By default, calculate on the energy grid supplied and then interpolate the resulting cross section.
If interpolateWidths==True, interpolate the average widths during reconstruction instead.
-
getFluctuationIntegrals
(widths, DOF)[source]¶ From subroutine GNRL3 in RECENT. If possible, this will be replaced with more basic approach (rather than using lookup table)... not finding appropriate equations right now
Comments from GNRL3 sourcecode:
Calculate unresolved resonance fluctuation function (original coding from AVERAGE4 by Mulki Bhat) (new weighting scheme from MC^2-II) This routine has been modified to calculate elastic, capture and fission fluctuation functions all during one call (as opposed to the original version which calculated each reaction separately). GNX, GGX, GFX and GXX are the widths for elastic, capture, fission and competition. MUN, MUF and MUX are the number of degrees of freedom for elastic, fission and competition (infinite number of degrees assumed for capture). RN, RC and RF are the calculated fluctuation integrals for elastic, capture and fission The number of degrees of freedom for each distribution (elastic, fission or competition) may be 1 to 4. If the number of degrees of freedom for any distribution is less than 1 or more than 4 it will be treated as an infinite number of degrees of freedom (which infers that the widths are not distributed, but are rather all equal to the average value). This last case is simulated by defining an additional 10 point quadrature in which the weight for one point is 1.0 and the weight for all other points is zero. for the one point of weight 1.0 the average width will be used.
-
getLastResolvedResonanceEnergy
(l=None, j=None)[source]¶ Get the last resonance energy from the resolved region, that will start all the ladders in the URR
Parameters: - l – orbital angular momentum of the resonance to find
- j – total angular momentum of the resonance to find
Returns: either the energy of the last resonance with requested (l,j) or None if it can’t be found
-
getLastResolvedResonanceRegion
()[source]¶ Get the highest energy resonance ENDF region in the resolved resonance region (which may contain more than one ENDF region)
Returns: The ENDF resolved resonance region, or None if there is no ENDF region in the data
-
getTransmissionCoefficientsFromSumRule
(skipFission=True)[source]¶ - Use Moldauer’s sum rule to extract the transmission coefficients directly from the URR tables
- P.A. Moldauer Phys. Rev. Lett. 19, 1047-1048 (1967)
Parameters: skipFission – flag to skip fission, what else? Returns: a dictionary of results, sorted by channel
-
getURRPDF
(resClass, nSamples=2000, style='goe', interpolateWidths=True, NE=100, ELowerBound=None, EUpperBound=None, NXS=200, XSLowerBound=None, XSUpperBound=None, verbose=True, restart=False, timing=False, memory=False)[source]¶ - About restart files: they json dumps of the URR PDF, but before being renomalized. In other words, they are pure histograms
- of number of points of the cross section curve in an energy/cross section voxel. This is a poor-mans path-length in the voxel.
At end of the run, the URR PDF (which, as I said, is still just a histogram) is normalized properly, turning it into a true PDF.
Parameters: - resClass – The class instance to use for reconstructing realizations of the cross section set.
- nSamples –
- style – not the GND style, rather the style of resonance generation (see sampleRR)
- interpolateWidths – interpolate the URR widths or not (just say “True”)
- NE – number of energy bins in the PDF (# bin boundaries is NE+1)
- ELowerBound –
- EUpperBound –
- NXS – number of cross section bins in the PDF (# bin boundaries is NXS+1)
- XSLowerBound –
- XSUpperBound –
- verbose – enable verbose output
- restart – enable restart capability
- timing – enable printing out timings
- memory – enable printing out memory usage of the resonance data structure
Returns:
-
getWidthsAndSpacings
(egrid, interpolateWidths=False)[source]¶ The ENDF URR tables give us the average resonance parameters, the average resonance spacing and the number of degrees of freedom, assuming that the widths are distributed by a chi^2 probability density function with the given number of degrees of freedom.
However, later we’ll need the level densities. Below we’ll construct them from the average resonance spacing for each L, J.
This function sets several member data as dicts (indexed by L & J) of data and interpolateable functions:
- levelSpacings: level spacings from ENDF:: ..math:: D_{L,J}(E) - averageWidths: average widths from ENDF:: ..math:: \Gamma_{L,J,c} - levelSpacingFuncs: level spacings from ENDF, turned into interpolation tables (using XYs.XYs1d instances) - levelDensityFuncs: level density as interpolation tables (using XYs.XYs1d instances), derived from level spacings ..math::
ho_{L,J}(E)=1/D_{L,J}(E)
- averageWidthFuncs: average widths from ENDF, turned into interpolation tables (using XYs.XYs1d instances)
- DOFs: degrees of freedom from ENDF
param egrid: the grid to work on param interpolateWidths: flag to determine whether to interpolate the resonance widths return: None
-
rho
(E)[source]¶ The dimensionless parameter rho:
..math::
ho = k(E) a
We always calculate channel radius for unresolved region according to the ENDF manual
param E: the incident neutron energy return: rho
-
sampleRR
(lastResonanceEnergies, lowerBound=None, upperBound=None, style='goe', verbose=True)[source]¶ Generate a sample of a resolved resonant set using the average URR parameters
Parameters: - lastResonanceEnergies – the energy of the last energy from the RRR
- verbose – turn on verbose output
Returns: the resonance set as a fudge.core.math.table
-
-
fudge.processing.resonances.reconstructResonances.
getAllowedTotalSpins
(L, S, useFactor2Trick=True)[source]¶ Returns a list of allowed J values from summing angular momenta L and S, where which implies
The useFactor2Trick flag tells the routine whether we are summing real angular momenta or momenta * 2. If the useFactor2Trick flag is true, then momenta are really momenta*2, meaning they can be pure integers, even if the real momenta refer to 1/2-integer values (e.g. spin). The default is to useFactor2Trick because most C/C++/Fortran codes that compute angular momentum-stuff use the trick so they can use integer math. Also, it makes the use of the Python range() function possible.
-
fudge.processing.resonances.reconstructResonances.
getR_S
(E, Eres, captureWidth, widths, penetrabilities)[source]¶ Both versions of Reich_Moore formalisms (LRF=3 and 7) rely on building the complex matrix ‘R’. Here we break it up into the real component R and the imaginary component S, which represent symmetric and anti-symmetric scattering respectively
matrix elements R[i,j] and S[i,j] =
(summed over resonances) partialWidth[i]*partialWidth[j] * coefficient/(dE**2+captureWidth**2),
for the ith/jth open channel. For S, the coefficient is ‘dE’, for R ‘captureWidth’ and partialWidth[i] = widths[i] * penetrabilities[i]
( widths[i] is a row vector of resonance widths, and penetrabilities[i] is a column vector of the penetrability for each incident energy )After computing R and S, invert using invertMatrices to find RI and SI such that (I+R+jS)*(I+RI+jSI) = I where I is the identity matrix, and j = sqrt(-1)
Incident energy dependence appears in both in E and the penetrabilities
-
fudge.processing.resonances.reconstructResonances.
getResonanceReconstructionClass
(formalismMoniker)[source]¶
-
fudge.processing.resonances.reconstructResonances.
invertMatrices
(R, S)[source]¶ find RI and SI such that (I+R+jS)*(I+RI+jSI) = I, where I is the identity matrix, and j = sqrt(-1)
for more info, see comments for subroutine FROBNS3 in recent.f
-
fudge.processing.resonances.reconstructResonances.
reconstructAngularDistributions
(reactionSuite, tolerance=None, verbose=False, energyUnit='eV')[source]¶ Reconstruct all pure two-body angular distributions from the resonance region. For MLBW and RM, that means ‘elastic’ channel only, but R-Matrix evaluations can support additional channels. SLBW cannot be used for angular distributions.
Returns a Python dict. They key is the reaction and the value is a reconstructed distributions.angular.XYs2d instance containing Legendre expansions for each incident energy.
-
fudge.processing.resonances.reconstructResonances.
reconstructResonances
(reactionSuite, tolerance=None, verbose=False, significantDigits=None, energyUnit='eV')[source]¶ Reconstruct all resonance cross sections (resolved and unresolved) in reactionSuite, and add results together for full (resonance region) pointwise cross section.
Optional arguments: ‘tolerance’: fractional tolerance, used to refine interpolation grid.
e.g. if tolerance=0.001, points are added until lin-lin interpolation is good to 0.1% everywhere‘verbose’: print status messages during reconstruction
- ‘significantDigits’: Controls how many digits can be used to represent the energy grid. For example,
- if significantDigits=4 the resulting energy grid can contain 1.034, 1.035, 1.036 but not 1.0345. Using significantDigits=8 should allow data to be written back to ENDF-6 without loss of precision.
‘energyUnit’: unit to use for reconstruction. Resonance energies and widths will be converted to this unit.
-
fudge.processing.resonances.reconstructResonances.
reconstructURRCrossSectionPDF
(reactionSuite, tolerance=None, verbose=False, reconstructionScheme=None)[source]¶
-
class
fudge.processing.resonances.reconstructResonances.
resonanceReconstructionBaseClass
(reactionSuite, energyUnit='eV', **kw)[source]¶ Bases:
object
-
k
(energy)[source]¶ - For an incident neutron, with energy in eV, the ENDF manual states :math:`k =
rac{sqrt{2m_n}}{hbar} rac{AWRI}{AWRI+1}sqrt{|E|}`
sqrt( 2 * neutronMass ) / hbar == 2.196807e-3 (eV*barn)**-1/2. Thus for energy in eV, k is in b**-1/2
-
refineInterpolation
(egrid, xsecs, tolerance=0.01, significantDigits=None)[source]¶ generateEnergyGrid may not give a fine enough grid to linearly interpolate to desired tolerance. My solution to that: for all consecutive points (x0,y0), (x1,y1) and (x2,y2) do a linear interpolation between (x0,y0) and (x2,y2). If the interpolation doesn’t agree with (x1,y1) within tolerance, subdivide up the region by adding two more calculated points. Iterate until interpolation agrees within tolerance.
This means that in the end we will have more points than required for given tolerance. The results can be thinned (thinning implemented in xData.XYs1d)
-


You have successfully autheticated with {{registerData.provider}} . Please enter your email address below and click the Register button to log in.


Defines an API request.
constructFormdata() Constructs a FormData instance from an object.
the object to generate the FormData from
POST /api/auth/user/accept-guidelines/
- Promises to accept the user guidelines
POST /api/auth/users/:username/block/
- Promises to block a user by username
The username of the user to block
POST /api/auth/register/
(urlencoded) - Promises to create a user
The user's properties
delete() DELETE request
generateHeaders() A function used to generate the headers that need to be passed to the request performee.
get() GET request
GET /auth/auth/user/languages/
- Promises to get the user's languages
GET /api/auth/user/notifications-settings/
- Promises to retrieve the user's notification settings
GET /api/auth/blocked-users/
- Promises to get an array of blocked users
Query limitation parameters
Checks whether the request is authenticated
GET /api/auth/followers/
- Promises to get an array of followers
Query limitation parameters
Checks whether the request is authenticated
GET /api/auth/followings/
- Promises to get an array of followings
Query limitation parameters
Checks whether the request is authenticated
GET /api/auth/linked-users/
- Promises to get an array of linked users
Checks whether the request is authenticated
GET /api/auth/user/
- Promises to get a user by auth token
The authentication token
GET /api/auth/user/
- Promises to get a user by username
The username to search for
Checks whether the request is authenticated
GET /api/auth/user/
- Promises to get a user by a certain query
The search query
Checks whether the request is authenticated
POST /api/auth/email-check/
- Promises to check if an email address is available
The desired email address
POST /api/auth/username-check/
- Promises to check if a username is available
The desired username
POST /api/auth/login/
- Promises to log a user in
The username of the user
The password of the user
patch() PATCH request
Request body
patchFormdata() PATCH request (multipart/form-data, application/x-www-form-urlencoded)
post() POST request
Request body
postFormdata() POST request (multipart/form-data, application/x-www-form-urlencoded)
put() PUT request
Request body
putFormdata() PUT request (multipart/form-data, application/x-www-form-urlencoded)
POST /api/auth/users/:username/report/
- Promises to report a user
POST /api/auth/password/reset/
- Promises to initiate a password reset process
GET /api/auth/blocked-users/search/
- Promises to search between blocked users
The search query
The max number of results
GET /api/auth/followers/search
- Promises to search between followers
GET /api/auth/followings/search
- Promises to search between followings
GET /api/auth/linked-users/search/
- Promises to search a linked user
POST /api/auth/user/languages/
- Promises to set a new user language
The id of the desired language
POST /api/auth/users/:username/unblock/
- Promises to unblock a user by username
The username of the user to unblock
POST /api/auth/user/notifications-settings/
- Promises to update the user's notification settings
PATCH /api/auth/user/
(urlencoded) - Promises to create a user
The user's properties
PATCH /api/auth/user/settings/
(urlencoded) - Promises to update the user's email
The desired email address
PATCH /api/auth/user/settings/
(urlencoded) - Promises to update the user's passord
The user's current password
The user's desired new password
POST /api/auth/email/verify/
- Promises to verify a user's email
The verification token
POST /api/auth/password/verify/
- Promises to verify a password
Generated using TypeDoc
public AuthAPI - provides methods to interact with the Auth API