All key segment loop expansion tokens and field loop expansion tokens (for field segments) are available in Relation Key Segment Loops, and additionally the following tokens are available:
|
Token |
Description |
|
|
Inserts a string indicating the C# equivalent data type of a literal key segment of a foreign key that is referenced in the "from key" side of a relationship. Literal key segments defined in repository don't have a data type, only a value, so this token derives the data type by looking at the matching field segment in the relations associated "to key".
Possible values: bool, byte, double, float, int, long, decimal, DateTime, Nullable<DateTime>, sbyte, short, string, uint, ulong, ushort
Example: Consider a relationship involving the following two structures and keys:
Structure A Structure B FROM Foreign key TO Access key Segment 1, literal 0 Field rectype (D1) Segment 2, field customer (D6) Field customer (D6) In order to determine a data type for the literal segment in structure A, the code looks at the matching field segment in structure B. The field is a D1, so it will be represented as an int.
IMPORTANT NOTE: This token can ONLY be used in a relation FROM key segment loop, and further ONLY when processing a LITERAL segment, which can only exist in a FOREIGN key. The <IF SEG_TYPE_LITERAL> expression should be used to ensure this is the case. For example:
<RELATION_LOOP> <FROM_KEY_SEGMENT_LOOP> <IF SEG_TYPE_LITERAL> <LITERAL_SEGMENT_CSTYPE> </IF SEG_TYPE_LITERAL> </FROM_KEY_SEGMENT_LOOP> </RELATION_LOOP>
|
|
|
Inserts a string indicating the Synergy .NET equivalent data type of a literal key segment of a foreign key that is referenced in the "from key" side of a relationship. Literal key segments defined in repository don't have a data type, only a value, so this token derives the data type by looking at the matching field segment in the relations associated "to key".
Possible values: boolean, byte, double, float, int, long, decimal, DateTime, Nullable<DateTime>, sbyte, short, string, uint, ulong, ushort
Example: Consider a relationship involving the following two structures and keys:
Structure A Structure B FROM Foreign key TO Access key Segment 1, literal 0 Field rectype (D1) Segment 2, field customer (D6) Field customer (D6) In order to determine a data type for the literal segment in structure A, the code looks at the matching field segment in structure B. The field is a D1, so it will be represented as an int.
IMPORTANT NOTE: This token can ONLY be used in a relation FROM key segment loop, and further ONLY when processing a LITERAL segment, which can only exist in a FOREIGN key. The <IF SEG_TYPE_LITERAL> expression should be used to ensure this is the case. For example:
<RELATION_LOOP> <FROM_KEY_SEGMENT_LOOP> <IF SEG_TYPE_LITERAL> <LITERAL_SEGMENT_CSTYPE> </IF SEG_TYPE_LITERAL> </FROM_KEY_SEGMENT_LOOP> </RELATION_LOOP>
|
|
|
Inserts a string or numeric literal representing the value of a literal key segment of a foreign key that is referenced in the "from key" side of a relationship. Literal key segments defined in repository don't have a data type, only a value, so this token determines whether to insert a string or numeric literal by looking at the matching field segment in the relations associated "to key".
Possible values: •A numeric literal, e.g. 25 •A string literal, e.g. "ABC" Example: consider a relationship involving the following two structures and keys: Structure A Structure B FROM Foreign key TO Access key Segment 1, literal 0 Field rectype (D1) Segment 2, field customer (D6) Field customer (D6) In order to the type of literal value to insert for the literal segment in structure A, the code looks at the matching field segment in structure B. The field is a D1, so a numeric literal value will be inserted.
IMPORTANT NOTE: This token can ONLY be used in a relation FROM key segment loop, and further ONLY when processing a LITERAL segment, which can only exist in a FOREIGN key. The <IF SEG_TYPE_LITERAL> expression should be used to ensure this is the case. For example: <RELATION_LOOP> <FROM_KEY_SEGMENT_LOOP> <IF SEG_TYPE_LITERAL> <LITERAL_SEGMENT_VALUE> </IF SEG_TYPE_LITERAL> </FROM_KEY_SEGMENT_LOOP> </RELATION_LOOP>
|
Copyright © 2021 Synergex International, Inc.


--- layout: post title: 'MWI day: The Long Tail, Franklin Davis of Nokia' date: 2005-11-15 00:00:00 categories: interfaces-&-interaction mobile ---
The Long Tail, Franklin Davis of Nokia
We recognise that most of the long tail of content won't bother adapting their content.
HDML -> WAP 1.0 -> WAP hype -> WAP crash -> I-Mode success -> I-mode non-replication -> WAP 2.0 -> Walled gardens
(but this isn't actually accurate; WAP 1.0 and I-mode launched near-simultaneously, not consecutively)
If I have 5, 10, 15% of my traffic coming from mobile devices, then I will have users complaining that my site doesn't work, and it's then in *my* interest to fix my site. There's no motivation for content providers to do this until they have traffic.
Mobile browsing vision: "By 2015 most people will have access to most of human knowledge wherever they are all the time"
Key browsing use cases:
- LBS
- Subscriptions
- Infotainment (top one, filling odd moments of time or meeting spontaneous information needs)
- Content discovery.download (portals)
- Personal publishing
- Image galleries (how does this differ from PP)
Mobile browsers are stuck "before the chasm" - it's an early aadopter thing
New S60 web browser based on same core as Safari: KDE Konqueror
Based on zooming in and out of web pages
"People understand web pages"
Making it possible to use the full web. The idea being that once these sites are getting mobile visitors they'll start following W3C recommendations.
Has an RSS reader; right now doesn't do updating of feeds (future versions will do this)
I'm not massively impressed by the browser; if it's any good then why will anyone want to have content adapted for it. If it's bad, then why will anyone use it to browse sites in the first place? Seems to rely on a groundswell of users who are prepared to use it to have a poor experience.


SIMILE
Timeplot
George W. Bush Ratings
George W. Bush Ratings
Show values on the mouse location
Source:
NBC News/Wall Street Journal


Class BulkRedactorSettings
java.lang.Object
com.nuix.superutilities.annotations.BulkRedactorSettings
public class BulkRedactorSettings
extends java.lang.Object
Provides settings regarding bulk redaction performed by
BulkRedactor.findAndMarkup(Case, BulkRedactorSettings, Collection, int)
.- Author:
- Jason Wells
-
Constructor Summary
Constructors Constructor Description BulkRedactorSettings()
-
Method Summary
Modifier and Type Method Description void
addExpression(java.lang.String regularExpression)
Adds a regular expression to the list of expressions used to locate text to markup.void
addNamedEntity(java.lang.String namedEntityType)
Adds a named entity type to the list of types to be redacted.void
addPhrase(java.lang.String phrase)
Adds a phrase to the list of expressions used to find and markup text.void
addPhrases(java.util.Collection<java.lang.String> phrases)
Adds multiple phrases to the list of expressions used to find and markup text.static java.lang.String
escapeRegexSpecialCharacters(java.lang.String input)
Escapes regular expression characters in the input string.boolean
getApplyHighLights()
boolean
getApplyRedactions()
java.util.Set<java.lang.String>
getExpressions()
Gets the regular expressions which will be used to locate text to markup.nuix.MarkupSet
getMarkupSet(nuix.Case nuixCase)
Gets the Nuix MarkupSet object based on the markup set name as set bysetMarkupSetName(String)
.java.lang.String
getMarkupSetName()
Gets the name of the markup set to which markups will be recorded against.java.util.Set<java.lang.String>
getNamedEntityTypes()
Gets the list of named entity types to be redacted.java.io.File
getTempDirectory()
Gets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.static java.lang.String
phraseToExpression(java.lang.String phrase)
Converts a phrase (string with potentially multiple terms) into a regular expression for used searching for text to redact in a PDF.void
setApplyHighLights(boolean applyHighLights)
void
setApplyRedactions(boolean applyRedactions)
void
setExpressions(java.util.Collection<java.lang.String> expressions)
Sets the regular expressions which will be used to locate text to markup.void
setMarkupSetName(java.lang.String markupSetName)
Sets the name of the markup set to which markup will be recorded against.void
setNamedEntityTypes(java.util.Collection<java.lang.String> namedEntityTypes)
Sets the list of named entity type to be redacted.void
setTempDirectory(java.io.File tempDirectory)
Sets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.void
setTempDirectory(java.lang.String tempDirectory)
Sets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.static java.util.List<java.lang.String>
splitPhrase(java.lang.String phrase)
Splits a string into tokens on whitespace using the regular expression: \s+static java.lang.String
termToRegex(java.lang.String inputTerm)
Converts a plain text term to a regular expression which is case insensitive.
-
Constructor Details
-
BulkRedactorSettings
public BulkRedactorSettings()
-
-
Method Details
-
getMarkupSetName
public java.lang.String getMarkupSetName()Gets the name of the markup set to which markups will be recorded against.- Returns:
- The name of the markup set to use.
-
setMarkupSetName
public void setMarkupSetName(java.lang.String markupSetName)Sets the name of the markup set to which markup will be recorded against.- Parameters:
markupSetName
- The name of the markup set to use. If the name provided does not exist, a markup set will be created.
-
getTempDirectory
public java.io.File getTempDirectory()Gets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.- Returns:
- The PDF export temp directory.
-
setTempDirectory
public void setTempDirectory(java.io.File tempDirectory)Sets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.- Parameters:
tempDirectory
- The PDF export temp directory.
-
setTempDirectory
public void setTempDirectory(java.lang.String tempDirectory)Sets the temp directory to whichBulkRedactor
will export PDF files which will be provided to Aspose.- Parameters:
tempDirectory
- The PDF export temp directory.
-
getExpressions
public java.util.Set<java.lang.String> getExpressions()Gets the regular expressions which will be used to locate text to markup.- Returns:
- The regular expressions which will be used to locate text to markup.
-
setExpressions
public void setExpressions(java.util.Collection<java.lang.String> expressions)Sets the regular expressions which will be used to locate text to markup.- Parameters:
expressions
- The regular expressions which will be used to locate text to markup.
-
addExpression
public void addExpression(java.lang.String regularExpression)Adds a regular expression to the list of expressions used to locate text to markup.- Parameters:
regularExpression
- A regular expression to add
-
getNamedEntityTypes
public java.util.Set<java.lang.String> getNamedEntityTypes()Gets the list of named entity types to be redacted.- Returns:
- The list of named entity types to be redacted.
-
setNamedEntityTypes
public void setNamedEntityTypes(java.util.Collection<java.lang.String> namedEntityTypes)Sets the list of named entity type to be redacted.- Parameters:
namedEntityTypes
- The named entity types to be redacted.
-
addNamedEntity
public void addNamedEntity(java.lang.String namedEntityType)Adds a named entity type to the list of types to be redacted.- Parameters:
namedEntityType
- The named entity type to be added to the list.
-
getMarkupSet
public nuix.MarkupSet getMarkupSet(nuix.Case nuixCase)Gets the Nuix MarkupSet object based on the markup set name as set bysetMarkupSetName(String)
. If the markup set by the given name already exists, then this will yield that existing markup set. If it does not, a new markup set with the given name will be created.- Parameters:
nuixCase
- The relevant Nuix Case- Returns:
- Either the existing markup set or a newly created markup set, based on the markup set name as set by
setMarkupSetName(String)
.
-
escapeRegexSpecialCharacters
public static java.lang.String escapeRegexSpecialCharacters(java.lang.String input)Escapes regular expression characters in the input string.- Parameters:
input
- String with regular expression characters to escape.- Returns:
- String with the regular expression characters escaped.
-
termToRegex
public static java.lang.String termToRegex(java.lang.String inputTerm)Converts a plain text term to a regular expression which is case insensitive. This is done by generating a regular expression with a character class matching each letter in both lower case and upper case. For example if the input term is "cat", this returns a regular expression "[Cc][Aa][Tt]".- Parameters:
inputTerm
- Term to convert to a case insensitive regular expression- Returns:
- String Regular expression that is case insensitive regular expression for input term
-
splitPhrase
public static java.util.List<java.lang.String> splitPhrase(java.lang.String phrase)Splits a string into tokens on whitespace using the regular expression: \s+- Parameters:
phrase
- The phrase to tokenize.- Returns:
- List of token strings.
-
phraseToExpression
public static java.lang.String phraseToExpression(java.lang.String phrase)Converts a phrase (string with potentially multiple terms) into a regular expression for used searching for text to redact in a PDF.- Parameters:
phrase
- The phrase to convert into a regular expression. May be single or multiple terms.- Returns:
- A regular expression to match that phrase in a case insensitive manner. Internally calls
splitPhrase(String)
andtermToRegex(String)
.
-
addPhrase
public void addPhrase(java.lang.String phrase)Adds a phrase to the list of expressions used to find and markup text. Phrase is converted to an expression usingphraseToExpression(String)
. Resulting expression is then surrounded '\b' to anchor it to word boundaries.- Parameters:
phrase
- The phrase to add to the list of expressions used to find and markup text.
-
addPhrases
public void addPhrases(java.util.Collection<java.lang.String> phrases)Adds multiple phrases to the list of expressions used to find and markup text. Internally callsaddPhrase(String)
for each string in the provide value.- Parameters:
phrases
- Multiple phrases to the list of expressions used to find and markup text.
-
getApplyRedactions
public boolean getApplyRedactions() -
setApplyRedactions
public void setApplyRedactions(boolean applyRedactions) -
getApplyHighLights
public boolean getApplyHighLights() -
setApplyHighLights
public void setApplyHighLights(boolean applyHighLights)
-


Every encounter — whether it's online or offline — should move the user closer towards their goal.
Find Out MoreThe following design principles should serve as the backbone for the user experience, ensuring that the standards we set enable products that are easy to use and understand for consumers.
Honest, transparent design that wins the public’s trust.
Give them the control with information they need.
Maintain consistency and clarity. Align appearance with purpose.
Design for the widest possible demographic.
A minimal palette, clear hierarchy, good information design, and ample whitespace will ensure a voice of authority and expertise in communication.
The primary color palette for the agency is blue and black, including midtones and tints, and thoughtful use of whitespace.
These colors are used primarily as accent colors, and should be used to add variety to page content and illustrations. They should never overpower the core brand colors.
A clear typographic hierarchy is critical to the effective communication. Type should be light and well-spaced to reinforce the idea that the agency is open, modern, and approachable.
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
0123456789
Open Sans is the primary typeface and can be used across all formats from print to digital. Its round and geometric letterforms are approachable and modern. Open Sans is great for titling, pull-quotes and lists, and in some cases can be used for lengthy body copy. Italics are included in the brand typography but should only be used on rare occasion.
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
0123456789
Merriweather is the secondary typeface and is designed for digital executions. Its high x-height and round letterforms play nicely with Open Sans. Merriweather is well-suited for lengthy body copy. Bold is useful for highlighting or titling within body copy. The italic weights work nicely at a medium scale for pull-quotes or language with a human tone.
The iconic font and CSS toolkit
Font Awesome gives you scalable vector icons that can instantly be customized — size, color, drop shadow, and anything that can be done with the power of CSS.
| 16px | 20px | 24px | 32px |
|---|---|---|---|
The following primary benchmark sizes should be used for web sizing:
Icons should always be one color. If used over a color field, negative space should be knocked out.
Although color usage is flexible, icons should always be used in high contrast tones relative to the background to maximize legibility.


{% extends 'base.html' %} {% load staticfiles %} {% block css %} {% endblock css %} {% block js %} {% endblock js %} {% block bugzilla-body %}
Hover your mouse over each field label to get help for that field.
Sort results by: Reuse same sort as last time Bug Number Importance Assignee Last Changed


A plugin for Reveal.js allowing to easily add charts using Chart.js.
Copy the files Chart.min.js
and plugin.js
into the plugin folder of your reveal.js presentation, i.e. plugin/chart
.
Add the plugins to the dependencies in your presentation, as below.
<script src="plugin/chart/Chart.min.js"></script>
<script src="plugin/chart/plugin.js"></script>
<script>
Reveal.initialize({
// ...
plugins: [RevealChart],
// ...
})
</script>
The plugin has several parameters that you can set for your presentation by providing an chart
option in the reveal.js initialization options.
Note that all configuration parameters are optional and the defaults of Chart.js will be used for parameters that are not specified.
Reveal.initialize({
// ...
chart: {
defaults: {
global: {
title: { fontColor: '#FFF' },
legend: {
labels: { fontColor: '#FFF' },
},
},
scale: {
scaleLabel: { fontColor: '#FFF' },
gridLines: { color: '#FFF', zeroLineColor: '#FFF' },
ticks: { fontColor: '#FFF' },
},
},
line: {
borderColor: ['rgba(20,220,220,.8)', 'rgba(220,120,120,.8)', 'rgba(20,120,220,.8)'],
'borderDash': [
[5, 10],
[0, 0],
],
},
bar: {
backgroundColor: ['rgba(20,220,220,.8)', 'rgba(220,120,120,.8)', 'rgba(20,120,220,.8)'],
},
pie: {
backgroundColor: [
[
'rgba(0,0,0,.8)',
'rgba(220,20,20,.8)',
'rgba(20,220,20,.8)',
'rgba(220,220,20,.8)',
'rgba(20,20,220,.8)',
],
],
},
radar: { borderColor: ['rgba(20,220,220,.8)', 'rgba(220,120,120,.8)', 'rgba(20,120,220,.8)'] },
},
// ...
})
The defaults
parameter will overwrite Chart.defaults
. Furthermore, for any chart type, e.g. line, bar, etc., the parameters for the individual datasets can be specified. Where Chart.js allows to specify a single parameter for a particular dataset, the plugin allows to specify an array of values for this parameter, which will automatically be assigned to the different datasets. Note that if there are more datasets than elements in the array, the plugin will start again with the first value in the array.
A chart can be included in a slide by adding a canvas
element with the data-chart
attribute set to the desired chart type.
The chart can be configured within the canvas body by a JSON string embedded into an HTML comment.
<canvas data-chart="line">
<!--
{
"data": {
"labels": ["January"," February"," March"," April"," May"," June"," July"],
"datasets": [
{
"data":[65,59,80,81,56,55,40],
"label":"My first dataset","backgroundColor":"rgba(20,220,220,.8)"
},
{
"data":[28,48,40,19,86,27,90],
"label":"My second dataset","backgroundColor":"rgba(220,120,120,.8)"
}
]
},
"options": { "responsive": "true" }
}
-->
</canvas>
It is possible to provide the chart data by comma separated values and use the JSON string within the HTML comment to configure the chart layout.
<canvas class="stretch" data-chart="line">
My first dataset, 65, 59, 80, 81, 56, 55, 40
<!-- This is a comment that will be ignored -->
My second dataset, 28, 48, 40, 19, 86, 27, 90
<!--
{
"data" : {
"labels" : ["Enero", "Febrero", "Marzo", "Avril", "Mayo", "Junio", "Julio"],
"datasets" : [{ "borderColor": "#0f0", "borderDash": ["5","10"] }, { "borderColor": "#0ff" } ]
}
}
-->
</canvas>
The layout configuration provided in chart
parameter (see Configuration) will be used by default and only those parameters that are specified in a JSON string are used to overwrite the default values. If no JSON string is provided to configure the chart layout the default configuration is used. Note, that if no labels for the data points are provided by a JSON string, the plugin expects that the first row provides table headers.
<canvas data-chart="line">
Month, January, February, March, April, May, June, July My first dataset, 65, 59, 80, 81, 56, 55,
40 My second dataset, 28, 48, 40, 19, 86, 27, 90
</canvas>
The chart data can also be provided in an external CSV file. To include external data, the filename must be specified using the data-chart-src
attribute of the canvas
element. The CSV file is expected to only contain data values, whereas options for drawing the chart can be given as described above.
<canvas data-chart="bar" data-chart-src="data.csv">
<!--
{
"data" : {
"datasets" : [{ "backgroundColor": "#0f0" }, { "backgroundColor": "#0ff" } ]
},
"options": { "responsive": true, "scales": { "xAxes": [{ "stacked": true }], "yAxes": [{ "stacked": true }] } }
}
-->
</canvas>
The plugin recreates the charts on a slide change to show the Chart.js animations.


To receive a reminder of your username or to reset your password enter
the email address or cellphone number you used to register on the website.
A username reminder or link to reset your password will be sent to your
required contact method.
Fun with words
"fumana"
is a sesotho word meaning "find"
"sebetsa"
is a sesotho word meaning "work"
"fumana mosibetsi"
is a sesotho phrase meaning "find work"
"Betsie Drost"
website team member who did not know
finding work in sesotho would sound
like her name when she searched for
the phrase!"


Select the date and time to publish and/or unpublish the content item.
What languages would you like to schedule?


DfE enquiries
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
News story
Lord Hill congratulates the winners of the National Governors' Association's annual Outstanding School Governance Awards.
Schools Minister Lord Hill today congratulated the winners of the National Governors’ Association’s ‘Outstanding School Governance Awards 2011’.
Governing bodies are responsible for schools, their standards and their conduct. Governors aim to ensure that children are attending schools which provide them with a good education and support their well-being. Over the past decade the responsibilities of governing bodies have grown, and this continues with the increasing autonomy the Government is giving to schools.
There were two awards presented: one for outstanding governing bodies and one for outstanding clerks to governing bodies.
Lord Hill said:
Many school governors and clerks make an outstanding contribution to the job of running their own school and of helping to set the standards for all governing bodies. Today’s winners highlight some of the best and I am delighted to have the chance to congratulate and thank them.
Governing bodies should be the key strategic body for a school. We want to attract more excellent school governors and have more effective governing bodies supported by trained clerks. That is why we are making it easier for schools to choose more flexible governing bodies made up of people equipped with the right mix of skills to suit the needs of their particular school.
Further details about the awards can be found on the NGA website .
Central newsdesk 020 7783 8300
General enquiries 0370 000 2288
Published: 12 April 2011


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| InputFormat | An input data format. |
| JobConfigurable | That what may be configured. |
| Mapper | Maps input key/value pairs to a set of intermediate key/value pairs. |
| MapRunnable | Expert: Permits greater control of map processing. |
| OutputCollector | Passed to Mapper and Reducer implementations to collect
output data. |
| OutputFormat | An output data format. |
| Partitioner | Partitions the key space. |
| RecordReader | Reads key/value pairs from an input file FileSplit . |
| RecordWriter | Writes key/value pairs to an output file. |
| Reducer | Reduces a set of intermediate values which share a key to a smaller set of values. |
| Reporter | Passed to application code to permit alteration of status. |
| RunningJob | Includes details on a running MapReduce job. |
| Class Summary | |
|---|---|
| ClusterStatus | Summarizes the size and current state of the cluster. |
| FileSplit | A section of an input file. |
| InputFormatBase | A base class for InputFormat . |
| JobClient | JobClient interacts with the JobTracker network interface. |
| JobConf | A map/reduce job configuration. |
| JobTracker | JobTracker is the central location for submitting and tracking MR jobs in a network environment. |
| MapFileOutputFormat | An OutputFormat that writes MapFile s. |
| MapReduceBase | A class to implement the trivial close and configure methods. |
| MapRunner | Default MapRunnable implementation. |
| OutputFormatBase | A base class for OutputFormat . |
| SequenceFileInputFormat | An InputFormat for SequenceFile s. |
| SequenceFileOutputFormat | An OutputFormat that writes SequenceFile s. |
| SequenceFileRecordReader | An RecordReader for SequenceFile s. |
| TaskReport | A report on the state of a task. |
| TaskTracker | TaskTracker is a process that starts and tracks MR Tasks in a networked environment. |
| TaskTracker.Child | The main() for child processes. |
| TextInputFormat | An InputFormat for plain text files. |
| TextOutputFormat | An OutputFormat that writes plain text files. |
A system for scalable, fault-tolerant, distributed computation over large data collections.
Applications implement Mapper
and
Reducer
interfaces. These are submitted
as a JobConf
and are applied to data
stored in a FileSystem
.
See Google's original Map/Reduce paper for background information.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Use the above dropdown menu to quickly jump to specific projects, or to search for keywords in their
descriptions. The search will reduce the list of projects shown below to those matching the keyword.
{% for lp in landing_pages %}
{% if lp.urls %}
{% endif %}
{{ lp.authors.0 }}
{% if lp.authors.1 %}
et al.
{% endif %}
{% if not lp.is_public %}
Explore contributions using this search form. A selection of project(s), formula(s), and/or
identifier(s) updates the results table with basic information about the matching
contributions. Click the contribution identifier to render its preview card as it is (or
will be) shown on the materials details pages of Materials Project.
results
Fill out this form to apply for a project on MPContribs. Upon submission of your info an
email will be sent to an admin to approve your request. If approved, you can start uploading data to
your project which will appear on the project landing page. You can choose to add e-mails of other MPContribs
users who you'd like to be added to your project group as collaborators. Collaborators and
owners have identical permissions but the number of projects an owner can create is limited. Your data
will only be visible to you and your collaborators until you choose to make it public. Only public
contributions will appear on the detail pages of Materials Project.
The Jupyter notebooks shown below demonstrate how to use the
mpcontribs-client
python library to programmatically contribute, update and retrieve data through the
MPContribs API. A web app for interactive data
ingestion is coming soon. Send pull requests against
MPContribs to add/update notebooks here.


Customization and search options
Crux allows the user the flexibility to change many of the search and analysis parameters. Attributes like the output format and which peptides are selected from the protein database are controlled through numerous options. This page starts with some general information about options and then describe the use of some key crux options.
Introduction to options
A crux command is made up of four parts: executable name, command, options, and required arguments. Let's use a crux tide-search command as an example. Here is the general form.
$ crux tide-search [options] <mass spectra> <peptide index>
In this case, the command is tide-search. This is followed by zero or more optional arguments. Finally, the required arguments, listed above inside angle brackets, include the name of the file containing the spectra to be identified and the name of a peptide index produced previously by the tide-index command.
All of the available options are described for each command on the documentation pages. You can also get a list of available options by running a command with no arguments. For example, the command
$ crux tide-search
will produce output that looks like this:
bash-3.2$ ~/proj/crux/trunk/src/c/crux tide-search FATAL: Expected at least 2 arguments, but found 0 USAGE: crux tide-search [options] <tide spectra file> <tide database index> REQUIRED ARGUMENTS: <tide spectra file> The name of the file from which to parse the fragmentation spectra, in any of the file formats supported by ProteoWizard. Alternatively, the argument may be a binary spectrum file produced by a previous run of crux tide-search using the store-spectra parameter. Multiple files can be included on the command line (space delimited), prior to the name of the database. <tide database> Either a FASTA file or a directory containing a database index created by a previous run of crux tide-index. OPTIONAL ARGUMENTS: [--auto-mz-bin-width false|warn|fail] Automatically estimate optimal value for the mz-bin-width parameter from the spectra themselves. false=no estimation, warn=try to estimate but use the default value in case of failure, fail=try to estimate and quit in case of failure. Default = false. [--auto-precursor-window false|warn|fail] Automatically estimate optimal value for the precursor-window parameter from the spectra themselves. false=no estimation, warn=try to estimate but use the default value in case of failure, fail=try to estimate and quit in case of failure. Default = false. [--compute-sp T|F] Compute the preliminary score Sp for all candidate peptides. Report this score in the output, along with the corresponding rank, the number of matched ions and the total number of ions. This option is recommended if results are to be analyzed by Percolator.If sqt-output is enabled, then compute-sp is automatically enabled and cannot be overridden. Note that the Sp computation requires re-processing each observed spectrum, so turning on this switch involves significant computational overhead. Default = false. [--concat T|F] When set to T, target and decoy search results are reported in a single file, and only the top-scoring N matches (as specified via --top-match) are reported for each spectrum, irrespective of whether the matches involve target or decoy peptides. Default = false. [--deisotope] Perform a simple deisotoping operation across each MS2 spectrum. For each peak in an MS2 spectrum, consider lower m/z peaks. If the current peak occurs where an expected peak would lie for any charge state less than the charge state of the precursor, within mass tolerance, and if the current peak is of lower abundance, then the peak is removed. The value of this parameter is the mass tolerance, in units of parts-per-million. If set to 0, no deisotoping is performed. Default = 0. ...
 The following lines list all the options (only five of which are shown above). Crux options all begin with two dashes followed by the option name. The name is followed by a space and the appropriate argument. This example increases the verbosity to 40:
$ crux tide-search --verbosity 40 demo.ms2 small-yeast.fasta
Specifying options via a parameter file
One of the options listed, --parameter-file, is available for all Crux commands. The parameter file allows multiple options to be specified in a file. All of the command line options can be put in a parameter file, but the format is slightly different. In the parameter file, the two leading dashes are removed from the option name, and the option name and value must be separated by an equal sign instead of a space:
<option name>=<argument>
The above example, in which we changed the verbosity, would look like this in a parameter file:
verbosity=40
The parameter file allows only one option per line. Lines beginning with "#" are considered comments and are ignored. A sample parameter file can be found here. Command line and parameter file options may be used separately or together. If an option is specified in both places, then value on the command line will be used.
During execution of any Crux command, a parameter file containing the
name and value of all the options for the current operation
will be automatically be saved in the output directory. Note that not
all parameters in the file may have been used in the operation. The
parameter file will be named
<command>.params.txt
,
where <tag>
is the name of the command that was
executed.
Shared options
In addition to --parameter-file
, Crux includes several
other options that are shared across all, or nearly all, Crux commands.
-
--output-dir <filename>
– The name of the directory where output files will be created. Default = crux-output. -
--fileroot <string>
– Thefileroot
string will be added as a prefix to all output file names. Default = none. -
--overwrite <T|F>
– By default, if Crux detects that the output file it is about to produce already exists, then Crux will exit with an error. This option allows Crux to overwrite existing files. -
--verbosity <0-100>
– Specify the verbosity of the current command. Each level prints the following messages, including all those at lower verbosity levels: 0-fatal errors, 10-non-fatal errors, 20-warnings, 30-information on the progress of execution, 40-more progress information, 50-debug info, 60-detailed debug info. Default = 30. -
In addition, many Crux commands include various options of the form
--<format>-output
. These options take Boolean arguments (specified as "T" or "F") and indicate whether output files in the specified format should be produced. For example, in addition to tab-delimited text format,tide-search
can produce output in PepXML, MZid, SQT and PINxml formats.
Changing the indexing and searching parameters
Various options to tide-index control how
the proteins in the database are converted to peptides. These options
fall into several categories, allowing specification of peptide
properties such as minimum and maximum length, enzymatic digestion
rules, decoy database generation and specification of various static
and variable modifications. These options are fully
documented here. Similarly,
the tide-search
documentation describes options for selecting which spectra to score,
the rules for selecting candidate peptides for a given spectrum, and
for deciding what kinds of scores to report.


--- layout: default title: Contact Hera ---
Send me feedback, critiques, cake, and most importantly: fork and contribute. Hera


Gecode::Int::ViewValGraph::Node< View > Class Template Reference
Base-class for nodes (both view and value nodes). More...
#include <view-val-graph.hh>
Public Member Functions | |
| Node (void) | |
| Initialize. | |
| Edge< View > * | edge_fst (void) const |
| Return first edge (organized by bi-links). | |
| Edge< View > * | edge_lst (void) const |
| Return last edge (organized by bi-links). | |
Static Public Member Functions | |
| static void * | operator new (size_t, Space &) |
| Allocate memory from space. | |
| static void | operator delete (void *, size_t) |
| Needed for exceptions. | |
| static void | operator delete (void *, Space &) |
| Needed for exceptions. | |
Public Attributes | |
| Edge< View > * | iter |
| Next edge for computing strongly connected components. | |
| unsigned int | low |
| Values for computing strongly connected components. | |
| unsigned int | min |
| unsigned int | comp |
Detailed Description
template<class View>
class Gecode::Int::ViewValGraph::Node< View >
Base-class for nodes (both view and value nodes).
Note: the obvious ill-design to have also nodes and edges parametric wrt View is because the right design (having template function members) gets miscompiled (and actually not even compiled with some C++ compilers). Duh!
Definition at line 116 of file view-val-graph.hh.
Constructor & Destructor Documentation
template<class View >
| Gecode::Int::ViewValGraph::Node< View >::Node | ( | void | ) | [inline] |
Member Function Documentation
template<class View >
| Edge< View > * Gecode::Int::ViewValGraph::Node< View >::edge_fst | ( | void | ) | const [inline] |
template<class View >
| Edge< View > * Gecode::Int::ViewValGraph::Node< View >::edge_lst | ( | void | ) | const [inline] |
template<class View >
| void * Gecode::Int::ViewValGraph::Node< View >::operator new | ( | size_t | s, | |
| Space & | home | |||
| ) | [inline, static] |
template<class View >
| void Gecode::Int::ViewValGraph::Node< View >::operator delete | ( | void * | , | |
| size_t | ||||
| ) | [inline, static] |
template<class View >
| void Gecode::Int::ViewValGraph::Node< View >::operator delete | ( | void * | , | |
| Space & | ||||
| ) | [inline, static] |
Member Data Documentation
template<class View>
| Edge<View>* Gecode::Int::ViewValGraph::Node< View >::iter |
Next edge for computing strongly connected components.
Definition at line 119 of file view-val-graph.hh.
template<class View>
| unsigned int Gecode::Int::ViewValGraph::Node< View >::low |
Values for computing strongly connected components.
Definition at line 121 of file view-val-graph.hh.
template<class View>
| unsigned int Gecode::Int::ViewValGraph::Node< View >::min |
Definition at line 121 of file view-val-graph.hh.
template<class View>
| unsigned int Gecode::Int::ViewValGraph::Node< View >::comp |
Definition at line 121 of file view-val-graph.hh.
The documentation for this class was generated from the following files:
- gecode/int/view-val-graph.hh
- gecode/int/view-val-graph/node.hpp


Solvers¶
FEA Solve¶
- class
feastruct.solvers.feasolve.
Solver
(analysis, analysis_cases, solver_settings)[source]¶Parent class for a finite element solver.
Provides a number of methods suitable for most finite element analysis solver types.
Variables:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver- ndof (int) – Number of active degrees of freedom in the analysis
__init__
(analysis, analysis_cases, solver_settings)[source]¶Inits the Solver class.
Parameters:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver
apply_bcs
(K, f_ext, analysis_case)[source]¶Applies the boundary conditions to the global stiffness matrix and external force vector for the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vector- analysis_case (
AnalysisCase
) – Analysis caseReturns: The global stiffness matrix and external force vector, modified by the boundary conditions (K, f_ext)
Return type: tuple(
scipy.sparse.lil_matrix
,numpy.ndarray
)
assemble_fext
(analysis_case)[source]¶Assembles the external force vector for analysis_case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case used to assemble the external force vectorReturns: The external force vector f_ext and the equivalent nodal loads vector f_eq Return type: tuple( numpy.ndarray
,numpy.ndarray
)
assemble_mass_matrix
()[source]¶Assembles the global stiffness using the sparse COO format.
Returns: The global mass matrix Return type: scipy.sparse.coo_matrix
assemble_stiff_matrix
(geometric=False, analysis_case=None)[source]¶Assembles the global stiffness using the sparse COO format.
Parameters:
- geometric (bool) – If set to True, also returns the global geometric stiffness matrix
- analysis_case (
AnalysisCase
) – If geometric is set to True, the static analysis case from which to use to build the geometric stiffness matrixReturns: The global stiffness matrix and, if desired, the global geometric stiffness matrix (K, K_g)
Return type: tuple(
scipy.sparse.coo_matrix
,scipy.sparse.coo_matrix
)
assign_dofs
()[source]¶Method to assign global degrees of freedom to the nodes in the analysis object.
calculate_reactions
(K, u, f_eq, analysis_case)[source]¶Calculates the reactions using the stiffness matrix K and the displacement vector u and saves the reactions for the analysis case.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- u (
numpy.ndarray
) – Displacement vector- f_eq (
numpy.ndarray
) – Global equivalent nodal loads vector of size N- analysis_case (
AnalysisCase
) – Analysis case
calculate_stresses
(analysis_case)[source]¶Calculates and saves the element stresses for the analysis case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case
cgs_solver
(K, f_ext)[source]¶Solves Ku=f_ext for u using the cgs method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
Raises: Exception – If the cgs solver does not converge or if the preconditioner fails
direct_solver
(K, f_ext)[source]¶Solves Ku=f_ext for u using the direct method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
function_timer
(text, function, *args)[source]¶Displays the message text and returns the time taken for a function, with arguments args, to execute. The value returned by the timed function is also returned.
Parameters:
- text (string) – Message to display
- function (function) – Function to time and execute
- args – Function arguments
Returns: Value returned from the function
remove_constrained_dofs
(K, analysis_case)[source]¶Given an initial matrix K, returns a new matrix with the constrained degrees of freedom removed. The constrained degrees of freedom are those with supports defined in the freedom case used in the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Stiffness matrix- analysis_case (
AnalysisCase
) – Analysis caseReturns: A new stiffness matrix with the constrined dofs removed
Return type:
scipy.sparse.lil_matrix
save_buckling_results
(w, v, analysis_case)[source]¶Saves the buckling results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
save_displacements
(u, analysis_case)[source]¶Saves the displacements u to the degree of freedom objects for the analysis case.
Parameters:
- u (
numpy.ndarray
) – Displacement vector- analysis_case (
AnalysisCase
) – Analysis case
save_frequency_results
(w, v, analysis_case)[source]¶Saves the frequency results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
solve_eigenvalue
(A, M, eigen_settings)[source]¶Finds eigenvalues and eigenvectors for A * x[i] = w[i] * M * x[i].
Parameters:
- A (
scipy.sparse.coo_matrix
) – A matrix- M (
scipy.sparse.coo_matrix
) – M matrix- eigen_settings (
feastruct.solvers.feasolve.LinearBucklingSettings
orfeastruct.solvers.feasolve.NaturalFrequencySettings
) – A settings object for use with the eigenvalue solverReturns: Eigenvalues and corresponding eigenvectors (w, v)
Return type: tuple(
numpy.ndarray
,numpy.ndarray
)Raises: Exception – If the eigenvalue solver does not converge
Linear Static Solver¶
- class
feastruct.solvers.linstatic.
LinearStatic
(analysis, analysis_cases, solver_settings=None)[source]¶Bases:
feastruct.solvers.feasolve.Solver
Class for a linear static solver.
Variables:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver- ndof (int) – Number of degrees of freedom in the analysis
__init__
(analysis, analysis_cases, solver_settings=None)[source]¶Inits the LinearStatic class.
Parameters:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver - if not supplied, the default settings are adopted
apply_bcs
(K, f_ext, analysis_case)¶Applies the boundary conditions to the global stiffness matrix and external force vector for the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vector- analysis_case (
AnalysisCase
) – Analysis caseReturns: The global stiffness matrix and external force vector, modified by the boundary conditions (K, f_ext)
Return type: tuple(
scipy.sparse.lil_matrix
,numpy.ndarray
)
assemble_fext
(analysis_case)¶Assembles the external force vector for analysis_case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case used to assemble the external force vectorReturns: The external force vector f_ext and the equivalent nodal loads vector f_eq Return type: tuple( numpy.ndarray
,numpy.ndarray
)
assemble_mass_matrix
()¶Assembles the global stiffness using the sparse COO format.
Returns: The global mass matrix Return type: scipy.sparse.coo_matrix
assemble_stiff_matrix
(geometric=False, analysis_case=None)¶Assembles the global stiffness using the sparse COO format.
Parameters:
- geometric (bool) – If set to True, also returns the global geometric stiffness matrix
- analysis_case (
AnalysisCase
) – If geometric is set to True, the static analysis case from which to use to build the geometric stiffness matrixReturns: The global stiffness matrix and, if desired, the global geometric stiffness matrix (K, K_g)
Return type: tuple(
scipy.sparse.coo_matrix
,scipy.sparse.coo_matrix
)
assign_dofs
()¶Method to assign global degrees of freedom to the nodes in the analysis object.
calculate_reactions
(K, u, f_eq, analysis_case)¶Calculates the reactions using the stiffness matrix K and the displacement vector u and saves the reactions for the analysis case.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- u (
numpy.ndarray
) – Displacement vector- f_eq (
numpy.ndarray
) – Global equivalent nodal loads vector of size N- analysis_case (
AnalysisCase
) – Analysis case
calculate_stresses
(analysis_case)¶Calculates and saves the element stresses for the analysis case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case
cgs_solver
(K, f_ext)¶Solves Ku=f_ext for u using the cgs method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
Raises: Exception – If the cgs solver does not converge or if the preconditioner fails
direct_solver
(K, f_ext)¶Solves Ku=f_ext for u using the direct method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
function_timer
(text, function, *args)¶Displays the message text and returns the time taken for a function, with arguments args, to execute. The value returned by the timed function is also returned.
Parameters:
- text (string) – Message to display
- function (function) – Function to time and execute
- args – Function arguments
Returns: Value returned from the function
remove_constrained_dofs
(K, analysis_case)¶Given an initial matrix K, returns a new matrix with the constrained degrees of freedom removed. The constrained degrees of freedom are those with supports defined in the freedom case used in the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Stiffness matrix- analysis_case (
AnalysisCase
) – Analysis caseReturns: A new stiffness matrix with the constrined dofs removed
Return type:
scipy.sparse.lil_matrix
save_buckling_results
(w, v, analysis_case)¶Saves the buckling results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
save_displacements
(u, analysis_case)¶Saves the displacements u to the degree of freedom objects for the analysis case.
Parameters:
- u (
numpy.ndarray
) – Displacement vector- analysis_case (
AnalysisCase
) – Analysis case
save_frequency_results
(w, v, analysis_case)¶Saves the frequency results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
solve_eigenvalue
(A, M, eigen_settings)¶Finds eigenvalues and eigenvectors for A * x[i] = w[i] * M * x[i].
Parameters:
- A (
scipy.sparse.coo_matrix
) – A matrix- M (
scipy.sparse.coo_matrix
) – M matrix- eigen_settings (
feastruct.solvers.feasolve.LinearBucklingSettings
orfeastruct.solvers.feasolve.NaturalFrequencySettings
) – A settings object for use with the eigenvalue solverReturns: Eigenvalues and corresponding eigenvectors (w, v)
Return type: tuple(
numpy.ndarray
,numpy.ndarray
)Raises: Exception – If the eigenvalue solver does not converge
Linear Buckling Solver¶
- class
feastruct.solvers.linbuckling.
LinearBuckling
(analysis, analysis_cases, solver_settings=None)[source]¶Bases:
feastruct.solvers.feasolve.Solver
Class for a linear buckling solver.
Variables:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver- ndof (int) – Number of degrees of freedom in the analysis
__init__
(analysis, analysis_cases, solver_settings=None)[source]¶Inits the LinearBuckling class.
Parameters:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver - if not supplied, the default settings are adopted
apply_bcs
(K, f_ext, analysis_case)¶Applies the boundary conditions to the global stiffness matrix and external force vector for the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vector- analysis_case (
AnalysisCase
) – Analysis caseReturns: The global stiffness matrix and external force vector, modified by the boundary conditions (K, f_ext)
Return type: tuple(
scipy.sparse.lil_matrix
,numpy.ndarray
)
assemble_fext
(analysis_case)¶Assembles the external force vector for analysis_case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case used to assemble the external force vectorReturns: The external force vector f_ext and the equivalent nodal loads vector f_eq Return type: tuple( numpy.ndarray
,numpy.ndarray
)
assemble_mass_matrix
()¶Assembles the global stiffness using the sparse COO format.
Returns: The global mass matrix Return type: scipy.sparse.coo_matrix
assemble_stiff_matrix
(geometric=False, analysis_case=None)¶Assembles the global stiffness using the sparse COO format.
Parameters:
- geometric (bool) – If set to True, also returns the global geometric stiffness matrix
- analysis_case (
AnalysisCase
) – If geometric is set to True, the static analysis case from which to use to build the geometric stiffness matrixReturns: The global stiffness matrix and, if desired, the global geometric stiffness matrix (K, K_g)
Return type: tuple(
scipy.sparse.coo_matrix
,scipy.sparse.coo_matrix
)
assign_dofs
()¶Method to assign global degrees of freedom to the nodes in the analysis object.
calculate_reactions
(K, u, f_eq, analysis_case)¶Calculates the reactions using the stiffness matrix K and the displacement vector u and saves the reactions for the analysis case.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- u (
numpy.ndarray
) – Displacement vector- f_eq (
numpy.ndarray
) – Global equivalent nodal loads vector of size N- analysis_case (
AnalysisCase
) – Analysis case
calculate_stresses
(analysis_case)¶Calculates and saves the element stresses for the analysis case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case
cgs_solver
(K, f_ext)¶Solves Ku=f_ext for u using the cgs method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
Raises: Exception – If the cgs solver does not converge or if the preconditioner fails
direct_solver
(K, f_ext)¶Solves Ku=f_ext for u using the direct method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
function_timer
(text, function, *args)¶Displays the message text and returns the time taken for a function, with arguments args, to execute. The value returned by the timed function is also returned.
Parameters:
- text (string) – Message to display
- function (function) – Function to time and execute
- args – Function arguments
Returns: Value returned from the function
remove_constrained_dofs
(K, analysis_case)¶Given an initial matrix K, returns a new matrix with the constrained degrees of freedom removed. The constrained degrees of freedom are those with supports defined in the freedom case used in the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Stiffness matrix- analysis_case (
AnalysisCase
) – Analysis caseReturns: A new stiffness matrix with the constrined dofs removed
Return type:
scipy.sparse.lil_matrix
save_buckling_results
(w, v, analysis_case)¶Saves the buckling results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
save_displacements
(u, analysis_case)¶Saves the displacements u to the degree of freedom objects for the analysis case.
Parameters:
- u (
numpy.ndarray
) – Displacement vector- analysis_case (
AnalysisCase
) – Analysis case
save_frequency_results
(w, v, analysis_case)¶Saves the frequency results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
solve_eigenvalue
(A, M, eigen_settings)¶Finds eigenvalues and eigenvectors for A * x[i] = w[i] * M * x[i].
Parameters:
- A (
scipy.sparse.coo_matrix
) – A matrix- M (
scipy.sparse.coo_matrix
) – M matrix- eigen_settings (
feastruct.solvers.feasolve.LinearBucklingSettings
orfeastruct.solvers.feasolve.NaturalFrequencySettings
) – A settings object for use with the eigenvalue solverReturns: Eigenvalues and corresponding eigenvectors (w, v)
Return type: tuple(
numpy.ndarray
,numpy.ndarray
)Raises: Exception – If the eigenvalue solver does not converge
Natural Frequency Solver¶
- class
feastruct.solvers.naturalfrequency.
NaturalFrequency
(analysis, analysis_cases, solver_settings=None)[source]¶Bases:
feastruct.solvers.feasolve.Solver
Class for a natural frequency solver.
Variables:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver- ndof (int) – Number of degrees of freedom in the analysis
__init__
(analysis, analysis_cases, solver_settings=None)[source]¶Inits the NaturalFrequency class.
Parameters:
- analysis (
FiniteElementAnalysis
) – Analysis object to solve- analysis_cases (list[
AnalysisCase
]) – List of analysis cases to solve- solver_settings (
SolverSettings
) – Settings to use in the solver - if not supplied, the default settings are adopted
apply_bcs
(K, f_ext, analysis_case)¶Applies the boundary conditions to the global stiffness matrix and external force vector for the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vector- analysis_case (
AnalysisCase
) – Analysis caseReturns: The global stiffness matrix and external force vector, modified by the boundary conditions (K, f_ext)
Return type: tuple(
scipy.sparse.lil_matrix
,numpy.ndarray
)
assemble_fext
(analysis_case)¶Assembles the external force vector for analysis_case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case used to assemble the external force vectorReturns: The external force vector f_ext and the equivalent nodal loads vector f_eq Return type: tuple( numpy.ndarray
,numpy.ndarray
)
assemble_mass_matrix
()¶Assembles the global stiffness using the sparse COO format.
Returns: The global mass matrix Return type: scipy.sparse.coo_matrix
assemble_stiff_matrix
(geometric=False, analysis_case=None)¶Assembles the global stiffness using the sparse COO format.
Parameters:
- geometric (bool) – If set to True, also returns the global geometric stiffness matrix
- analysis_case (
AnalysisCase
) – If geometric is set to True, the static analysis case from which to use to build the geometric stiffness matrixReturns: The global stiffness matrix and, if desired, the global geometric stiffness matrix (K, K_g)
Return type: tuple(
scipy.sparse.coo_matrix
,scipy.sparse.coo_matrix
)
assign_dofs
()¶Method to assign global degrees of freedom to the nodes in the analysis object.
calculate_reactions
(K, u, f_eq, analysis_case)¶Calculates the reactions using the stiffness matrix K and the displacement vector u and saves the reactions for the analysis case.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- u (
numpy.ndarray
) – Displacement vector- f_eq (
numpy.ndarray
) – Global equivalent nodal loads vector of size N- analysis_case (
AnalysisCase
) – Analysis case
calculate_stresses
(analysis_case)¶Calculates and saves the element stresses for the analysis case.
Parameters: analysis_case ( AnalysisCase
) – Analysis case
cgs_solver
(K, f_ext)¶Solves Ku=f_ext for u using the cgs method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
Raises: Exception – If the cgs solver does not converge or if the preconditioner fails
direct_solver
(K, f_ext)¶Solves Ku=f_ext for u using the direct method.
Parameters:
- K (
scipy.sparse.lil_matrix
) – Global stiffness matrix- f_ext (
numpy.ndarray
) – External force vectorReturns: Displacement vector u
Return type:
numpy.ndarray
function_timer
(text, function, *args)¶Displays the message text and returns the time taken for a function, with arguments args, to execute. The value returned by the timed function is also returned.
Parameters:
- text (string) – Message to display
- function (function) – Function to time and execute
- args – Function arguments
Returns: Value returned from the function
remove_constrained_dofs
(K, analysis_case)¶Given an initial matrix K, returns a new matrix with the constrained degrees of freedom removed. The constrained degrees of freedom are those with supports defined in the freedom case used in the analysis case.
Parameters:
- K (
scipy.sparse.coo_matrix
) – Stiffness matrix- analysis_case (
AnalysisCase
) – Analysis caseReturns: A new stiffness matrix with the constrined dofs removed
Return type:
scipy.sparse.lil_matrix
save_buckling_results
(w, v, analysis_case)¶Saves the buckling results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
save_displacements
(u, analysis_case)¶Saves the displacements u to the degree of freedom objects for the analysis case.
Parameters:
- u (
numpy.ndarray
) – Displacement vector- analysis_case (
AnalysisCase
) – Analysis case
save_frequency_results
(w, v, analysis_case)¶Saves the frequency results w and v to the degree of freedom objects for the analysis case.
Parameters:
- w (
numpy.ndarray
) – Eigenvalues- v (
numpy.ndarray
) – Eigenvectors- analysis_case (
AnalysisCase
) – Analysis case
solve
()[source]¶Executes the natural frequency finite element solver and saves the relevant results.
solve_eigenvalue
(A, M, eigen_settings)¶Finds eigenvalues and eigenvectors for A * x[i] = w[i] * M * x[i].
Parameters:
- A (
scipy.sparse.coo_matrix
) – A matrix- M (
scipy.sparse.coo_matrix
) – M matrix- eigen_settings (
feastruct.solvers.feasolve.LinearBucklingSettings
orfeastruct.solvers.feasolve.NaturalFrequencySettings
) – A settings object for use with the eigenvalue solverReturns: Eigenvalues and corresponding eigenvectors (w, v)
Return type: tuple(
numpy.ndarray
,numpy.ndarray
)Raises: Exception – If the eigenvalue solver does not converge
Solver Settings¶
- class
feastruct.solvers.feasolve.
SolverSettings
[source]¶Class for settings to be used in a finite element analysis.
Variables:
- linear_static (
feastruct.solvers.feasolve.LinearStaticSettings
) – Linear static settings- linear_buckling (
feastruct.solvers.feasolve.LinearBucklingSettings
) – Linear buckling settings- natural_frequency (
feastruct.solvers.feasolve.NaturalFrequencySettings
) – Natural frequency settings
Linear Static Settings¶
-
class
feastruct.solvers.feasolve.
LinearStaticSettings
(time_info=False, solver_type='direct', cgs_tol=1e-05, cgs_maxiter=None, cgs_precond=True)[source]¶ Bases:
object
Class for settings to be used in a linear static analysis.
Variables: - time_info (bool) – If set to True, a detailed description of the computation and the time cost is printed to the terminal
- solver_type (string) – Solver type used to solve Ku = f - ‘direct’ or ‘cgs’
- cgs_tol (float) – Tolerance to achieve for the cgs solver
- cgs_maxiter (int) – Maximum number of iterations for the cgs solver
- cgs_precond (bool) – If set to True, calculates a preconditioner for K using an ILU decomposition
-
__init__
(time_info=False, solver_type='direct', cgs_tol=1e-05, cgs_maxiter=None, cgs_precond=True)[source]¶ Inits the LinearStaticSettings class.
Parameters: - time_info (bool) – If set to True, a detailed description of the computation and the time cost is printed to the terminal
- solver_type (string) – Solver type used to solve Ku = f - ‘direct’ or ‘cgs’
- cgs_tol (float) – Tolerance to achieve for the cgs solver
- cgs_maxiter (int) – Maximum number of iterations for the cgs solver
- cgs_precond (bool) – If set to True, calculates a preconditioner for K using an ILU decomposition
Linear Buckling Settings¶
-
class
feastruct.solvers.feasolve.
LinearBucklingSettings
(time_info=False, num_modes=4, shift=0, maxiter=None, tol=1e-09)[source]¶ Bases:
object
Class for settings to be used in a linear buckling analysis.
-
__init__
(time_info=False, num_modes=4, shift=0, maxiter=None, tol=1e-09)[source]¶ Inits the LinearBucklingSettings class.
Parameters: - time_info (bool) – If set to True, a detailed description of the computation and the time cost is printed to the terminal
- num_modes (int) – Number of modes to compute
- shift (float) – Finds eigenvalues near shift using the shift-invert mode
- maxiter (int) – Maximum number of iterations allowed
- tol (float) – Relative accuracy for eigenvalues (stopping criterion)
-
Natural Frequency Settings¶
-
class
feastruct.solvers.feasolve.
NaturalFrequencySettings
(time_info=False, num_modes=4, shift=0, maxiter=None, tol=1e-09)[source]¶ Bases:
object
Class for settings to be used in a natural frequency analysis.
-
__init__
(time_info=False, num_modes=4, shift=0, maxiter=None, tol=1e-09)[source]¶ Inits the NaturalFrequencySettings class.
Parameters: - time_info (bool) – If set to True, a detailed description of the computation and the time cost is printed to the terminal
- num_modes (int) – Number of modes to compute
- shift (float) – Finds eigenvalues near shift using the shift-invert mode
- maxiter (int) – Maximum number of iterations allowed
- tol (float) – Relative accuracy for eigenvalues (stopping criterion)
-


ve
beğendi
Lorem ipsum dolor sit amet.
Cupiditate minus ex molestias facere.
Commodi ipsum autem obcaecati recusandae?
ve
beğendi
Lorem ipsum dolor sit amet.
Cupiditate minus ex molestias facere.
Commodi ipsum autem obcaecati recusandae?
ve
beğendi
Lorem ipsum dolor sit amet.
Cupiditate minus ex molestias facere.
Commodi ipsum autem obcaecati recusandae?
ve
beğendi
Lorem ipsum dolor sit amet.
Cupiditate minus ex molestias facere.
Commodi ipsum autem obcaecati recusandae?
With supporting text below as a natural lead-in to additional content.
Go somewhereWith supporting text below as a natural lead-in to additional content.
Go somewhereWith supporting text below as a natural lead-in to additional content.
Go somewhere


Edit this text
Play with these fake form controls
Be careful not to ruin usability: try resizing these.
cursor: wait;
resize: none;
pointer-events: none;


public class ExcelFileManager extends Object
| Constructor and Description |
|---|
ExcelFileManager(String xlFilePath)
Creates a new instance of the test data excel reader using the
expected excel
file path
|
| Modifier and Type | Method and Description |
|---|---|
String |
getCellData(String rowName)
Reads cell data from the first sheet in the desired excel
workbook Reads cell
data using row name (1st column) only Reads cell data from the 2nd column
(1st Value in the test data file)
|
String |
getCellData(String rowName,
String columnName)
Reads cell data from the first sheet in the desired excel
workbook Reads cell
data using row name (1st column) and column name
|
String |
getCellData(String sheetName,
String rowName,
String columnName)
Reads cell data from a specific sheet name inside the excel file
Reads cell
data using row name (1st column) and column name
|
String |
getColumnNameUsingRowNameAndCellData(String rowName,
String cellData)
Looks for the column name that holds the cellData in the
specified rowName
and the default sheet name
|
String |
getColumnNameUsingRowNameAndCellData(String sheetName,
String rowName,
String cellData)
Looks for the column name that holds the cellData in the
specified rowName
and sheetName
|
int |
getLastColumnNumber()
Returns the last column number that contains a header value (zero
based)
assuming that you are working within the default sheet.
|
int |
getLastColumnNumber(String sheetName)
Returns the last column number that contains a header value (zero
based).
|
public ExcelFileManager(String xlFilePath)
xlFilePath
- the expected path for the target excel filepublic String getCellData(String rowName)
rowName
- the value of the first cell of the target rowpublic String getCellData(String rowName, String columnName)
rowName
- the value of the first cell of the target rowcolumnName
- the value of the first cell of the target columnpublic String getCellData(String sheetName, String rowName, String columnName)
sheetName
- the name of the target excel sheetrowName
- the value of the first cell of the target rowcolumnName
- the value of the first cell of the target columnpublic int getLastColumnNumber()
public int getLastColumnNumber(String sheetName)
sheetName
- the name of the target excel sheetpublic String getColumnNameUsingRowNameAndCellData(String sheetName, String rowName, String cellData)
sheetName
- the name of the target excel sheetrowName
- the value of the first cell of the target rowcellData
- the value of the target cell within the target rowpublic String getColumnNameUsingRowNameAndCellData(String rowName, String cellData)
rowName
- the value of the first cell of the target rowcellData
- the value of the target cell within the target rowCopyright © 2018. All rights reserved.


{% extends "template.html" %} {% block content %}
Hunger Less is a non-profit oranization that aims to connects people/ oranizations who have excess food supplies to charities and other non-profit organizations
who are willing to distribute them. We ourselves are involved in the distribution process and are striving to reduce hunger nationally.
Companies and persons (such as supermarkets and farmers) who have surplus food goods, which may be about to expire, can register and log into our application
in order to post excess food goods.
Either us or charties and other organizations may then see such posts and get in contact with the suppliers and organize pickup and distribution logistics.