| Opcode | Instruction | Op/En | 64-bit Mode | Compat/Leg Mode | Description |
|---|---|---|---|---|---|
| D4 0A | AAM | ZO | Invalid | Valid | ASCII adjust AX after multiply. |
| D4 ib | AAM imm8 | ZO | Invalid | Valid | Adjust AX after multiply to number base imm8. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| ZO | NA | NA | NA | NA |
Adjusts the result of the multiplication of two unpacked BCD values to create a pair of unpacked (base 10) BCD values. The AX register is the implied source and destination operand for this instruction. The AAM instruction is only useful when it follows an MUL instruction that multiplies (binary multiplication) two unpacked BCD values and stores a word result in the AX register. The AAM instruction then adjusts the contents of the AX register to contain the correct 2-digit unpacked (base 10) BCD result.
The generalized version of this instruction allows adjustment of the contents of the AX to create two unpacked digits of any number base (see the “Operation” section below). Here, the imm8 byte is set to the selected number base (for example, 08H for octal, 0AH for decimal, or 0CH for base 12 numbers). The AAM mnemonic is interpreted by all assemblers to mean adjust to ASCII (base 10) values. To adjust to values in another number base, the instruction must be hand coded in machine code (D4 imm8).
This instruction executes as described in compatibility mode and legacy mode. It is not valid in 64-bit mode.
IF 64-Bit Mode THEN #UD; ELSE tempAL ← AL; AH ← tempAL / imm8; (* imm8 is set to 0AH for the AAM mnemonic *) AL ← tempAL MOD imm8; FI; The immediate value (imm8) is taken from the second byte of the instruction.
The SF, ZF, and PF flags are set according to the resulting binary value in the AL register. The OF, AF, and CF flags are undefined.
| #DE | If an immediate value of 0 is used. |
| #UD | If the LOCK prefix is used. |
Same exceptions as protected mode.
Same exceptions as protected mode.
Same exceptions as protected mode.
| #UD | If in 64-bit mode. |


|
AssetTrackerRK
|
Class for reading or writing a u-blox command. More...
#include <UbloxGPS.h>
Public Member Functions | |
| UbloxCommandBase (uint8_t *buffer, size_t bufferSize) | |
| Construct a UbloxCommandBase object. Normally you'd use UbloxCommand instead, which handles the buffer management for you. More... | |
| virtual | ~UbloxCommandBase () |
| Destructor. | |
| bool | decode (char ch) |
| Decode a single character. More... | |
| void | discardToNextSync1 () |
| Used internally to discard invalid data. You probably won't need to call this. | |
| void | updateChecksum () |
| When preparing a command to send, updates the checksum, sync, and length bytes. More... | |
| void | calculateChecksum (uint8_t &ckA, uint8_t &ckB) const |
| Calculates the checksum based on the data in the buffer. More... | |
| void | addHandler (UbloxMessageHandler *handler) |
| Add a message handler. More... | |
| void | removeHandler (UbloxMessageHandler *handler) |
| Remove a message handler. More... | |
| void | callHandlers () |
| Used internally to call all of the message handlers that match this class and id. | |
| uint8_t | getMsgClass () const |
| Gets the message class of the current command. More... | |
| uint8_t | getMsgId () const |
| Gets the message ID of the current command. More... | |
| void | setClassId (uint8_t msgClass, uint8_t msgId) |
| When sending a message, sets the message class and ID. More... | |
| size_t | getPayloadLen () const |
| Gets the payload length, the number of bytes available from getData() | |
| const uint8_t * | getData () const |
| Get a const pointer to the data payload. More... | |
| bool | getData (size_t offset, void *data, size_t dataLen) const |
| Copies data from the buffer. More... | |
| bool | setData (size_t offset, const void *data, size_t dataLen) |
| Set data in the buffer. More... | |
| bool | appendData (const void *data, size_t dataLen) |
| Appends data into the buffer at the current payloadLen. More... | |
| bool | fillData (uint8_t value, size_t dataLen) |
| Works like appendData(), but fill with a value instead. More... | |
| uint8_t | getU1 (size_t offset) const |
| Get a uint8_t value at offset. More... | |
| bool | setU1 (size_t offset, uint8_t value) |
| Set a uint8_t value at offset in the payload. More... | |
| bool | appendU1 (uint8_t value) |
| Append a uint8_t value to the current end of the payload. More... | |
| int8_t | getI1 (size_t offset) const |
| Get a int8_t value (signed) at offset. More... | |
| bool | setI1 (size_t offset, int8_t value) |
| Set a int8_t value at offset in the payload. More... | |
| bool | appendI1 (int8_t value) |
| Append a int8_t value to the current end of the payload. More... | |
| uint16_t | getU2 (size_t offset) const |
| Get a uint16_t value (little endian) at offset. More... | |
| bool | setU2 (size_t offset, uint16_t value) |
| Set a uint16_t value at offset in the payload. More... | |
| bool | appendU2 (uint16_t value) |
| Append a uint16_t value to the current end of the payload. More... | |
| int16_t | getI2 (size_t offset) const |
| Get a int16_t value (little endian, signed) at offset. More... | |
| bool | setI2 (size_t offset, int16_t value) |
| Set an int16_t value at offset in the payload. More... | |
| bool | appendI2 (int16_t value) |
| Append an int16_t value to the current end of the payload. More... | |
| uint32_t | getU4 (size_t offset) const |
| Get a uint32_t value (little endian, 4 bytes) at offset. More... | |
| bool | setU4 (size_t offset, uint32_t value) |
| Set a uint32_t value at offset in the payload. More... | |
| bool | appendU4 (uint32_t value) |
| Append a uint32_t value to the current end of the payload. More... | |
| int32_t | getI4 (size_t offset) const |
| Get a int32_t value (little endian, 4 bytes, signed) at offset. More... | |
| bool | setI4 (size_t offset, int32_t value) |
| Set an int16_t value at offset in the payload. More... | |
| bool | appendI4 (int32_t value) |
| Append a int32_t value to the current end of the payload. More... | |
| float | getR4 (size_t offset) const |
| Get a float value (4 bytes) at offset. More... | |
| bool | setR4 (size_t offset, float value) |
| Set an float (4 byte floating point) value at offset in the payload. More... | |
| bool | appendR4 (float value) |
| Append a float (4 byte floating point) value to the current end of the payload. More... | |
| double | getR8 (size_t offset) const |
| Get a double value (8 bytes) at offset. More... | |
| bool | setR8 (size_t offset, double value) |
| Set an double (8 byte floating point) value at offset in the payload. More... | |
| bool | appendR8 (double value) |
| Append a double (8 byte floating point) value to the current end of the payload. More... | |
| const uint8_t * | getBuffer () const |
| Get a pointer to the buffer, typically to send data. More... | |
| size_t | getSendLength () const |
| Get the length of the data, typically to send it. More... | |
Protected Types | |
| enum | State { State::LOOKING_FOR_START, State::LOOKING_FOR_LENGTH, State::LOOKING_FOR_MESSAGE } |
| u-blox parsing state constants More... | |
Protected Attributes | |
| uint8_t * | buffer |
| Buffer to hold data (received data or data for composing a packet to send) | |
| size_t | bufferSize |
| Size of the buffer. Maximum payload is bufferSize - HEADER_PLUS_CRC_LEN. | |
| size_t | bufferOffset = 0 |
| Current offset being written to in buffer when using encode() | |
| size_t | payloadLen = 0 |
| Length of the data payload (0 = no data). This does not include the header or CRC. | |
| State | state = State::LOOKING_FOR_START |
| Current parsing state. | |
| std::vector< UbloxMessageHandler * > | handlers |
| Vector of message handler objects, contains filter and callback function to handle incoming messages. | |
Static Protected Attributes | |
| static const uint8_t | SYNC_1 = 0xb5 |
| value of the first sync byte at buffer[0] | |
| static const uint8_t | SYNC_2 = 0x62 |
| value of the second sync byte at buffer[1] | |
| static const size_t | CLASS_OFFSET = 2 |
| offset in buffer where the message class is stored | |
| static const size_t | ID_OFFSET = 3 |
| offset in buffer where the message ID is stored | |
| static const size_t | DATA_OFFSET = 6 |
| offset in buffer where data begins (after sync, class, id, and length) | |
| static const size_t | HEADER_PLUS_CRC_LEN = 8 |
| size of the header data (6 bytes) plus CRC (2 bytes). Minimum size of a valid packet with 0 bytes of payload data. | |
| static const size_t | CRC_START_OFFSET = 2 |
| offset in buffer where the CRC calculation starts (does not include sync bytes) | |
| static const size_t | CRC_HEADER_LEN = 4 |
| number of header bytes included in the CRC. The total CRC length is this plus payloadLen. | |
Class for reading or writing a u-blox command.
You normally won't use this class directly, but will do so indirectly two ways:
|
strongprotected |
| UbloxCommandBase::UbloxCommandBase | ( | uint8_t * | buffer, |
| size_t | bufferSize | ||
| ) |
Construct a UbloxCommandBase object. Normally you'd use UbloxCommand instead, which handles the buffer management for you.
| buffer | Pointer a buffer. Must remain valid for the life of this object. Must not be NULL. |
| bufferSize | Size of the buffer, a minimum of HEADER_PLUS_CRC_LEN (8) bytes. You will overwrite memory if the buffer is smaller than that. |
| void UbloxCommandBase::addHandler | ( | UbloxMessageHandler * | handler | ) |
Add a message handler.
| handler | A pointer to a filled in UbloxMessageHandler structure. |
Note the handler object must remain valid until removeHandler is called on it, so you probably want to make it a global variable or allocated with new. The exception is if you have a blocking function call and add and remove the handler within the scope of the function, then you can allocate the object on the stack.
| bool UbloxCommandBase::appendData | ( | const void * | data, |
| size_t | dataLen | ||
| ) |
Appends data into the buffer at the current payloadLen.
| data | Pointer to the data to copy from. |
| dataLen | The length of the data in bytes. |
The data will be copied only if it will fit in the buffer entirely. The data will never be truncated. The payloadLen will be increased by dataLen bytes.
|
inline |
Append a int8_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit.
|
inline |
Append an int16_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
|
inline |
Append a int32_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
|
inline |
Append a float (4 byte floating point) value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
|
inline |
Append a double (8 byte floating point) value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
|
inline |
Append a uint8_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit.
|
inline |
Append a uint16_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
|
inline |
Append a uint32_t value to the current end of the payload.
| value | The value to append |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied.
| void UbloxCommandBase::calculateChecksum | ( | uint8_t & | ckA, |
| uint8_t & | ckB | ||
| ) | const |
Calculates the checksum based on the data in the buffer.
The checksum is calculated not including the sync bytes or the CRC itself. This method returns the checksum values as parameters, so you can compare them.
The updateChecksum() method is typically used to calculate it for sending.
| bool UbloxCommandBase::decode | ( | char | ch | ) |
Decode a single character.
This is called after reading data from the GPS by serial or I2C.
| bool UbloxCommandBase::fillData | ( | uint8_t | value, |
| size_t | dataLen | ||
| ) |
Works like appendData(), but fill with a value instead.
| value | The uint8_t value to set. Often 0 to initialize to zero. |
| dataLen | The number of bytes to fill with value. |
Handy for pre-creating zero-filled command buffers that are zeroed out.
|
inline |
Get a pointer to the buffer, typically to send data.
This is a pointer to the first sync byte.
|
inline |
Get a const pointer to the data payload.
There are other methods to copy the data, and read out values like U2, R4, etc..
| bool UbloxCommandBase::getData | ( | size_t | offset, |
| void * | data, | ||
| size_t | dataLen | ||
| ) | const |
Copies data from the buffer.
| offset | The offset to being reading from. This is relative to the data payload, so 0 is the first byte of payload data (not the sync byte) |
| data | Buffer to copy data into |
| dataLen | The length of the data. This must be <= (payloadLen - offset) |
Will only return true if all of the data can be returned. If offset + dataLen > the payloadLen the false will be returned and no data will be returned.
|
inline |
Get a int8_t value (signed) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
|
inline |
Get a int16_t value (little endian, signed) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
|
inline |
Get a int32_t value (little endian, 4 bytes, signed) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
|
inline |
Gets the message class of the current command.
This can be used from a message handler to find the message class of the message that is being handled.
|
inline |
Gets the message ID of the current command.
This can be used from a message handler to find the message id of the message that is being handled.
| float UbloxCommandBase::getR4 | ( | size_t | offset | ) | const |
Get a float value (4 bytes) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| double UbloxCommandBase::getR8 | ( | size_t | offset | ) | const |
Get a double value (8 bytes) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
|
inline |
Get the length of the data, typically to send it.
It's the length from the first sync byte through the last CRC byte, including the data payload.
| uint8_t UbloxCommandBase::getU1 | ( | size_t | offset | ) | const |
Get a uint8_t value at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| uint16_t UbloxCommandBase::getU2 | ( | size_t | offset | ) | const |
Get a uint16_t value (little endian) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| uint32_t UbloxCommandBase::getU4 | ( | size_t | offset | ) | const |
Get a uint32_t value (little endian, 4 bytes) at offset.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| void UbloxCommandBase::removeHandler | ( | UbloxMessageHandler * | handler | ) |
Remove a message handler.
| handler | The handler to remove (same value you passed to addHandler) |
Note this will not free handler as it can't know if it was allocated on the stack, as a class member, global variable, or new. If you allocated the object with new, don't forget to delete it!
| void UbloxCommandBase::setClassId | ( | uint8_t | msgClass, |
| uint8_t | msgId | ||
| ) |
When sending a message, sets the message class and ID.
| msgClass | The class of the message |
| msgId | The ID of the message |
| bool UbloxCommandBase::setData | ( | size_t | offset, |
| const void * | data, | ||
| size_t | dataLen | ||
| ) |
Set data in the buffer.
| offset | The offset to write to. This is relative to the data payload, so 0 is the first byte of payload data (not the sync byte) |
| data | Pointer to the data to copy from. |
| dataLen | The length of the data in bytes. |
The data will be copied only if it will fit in the buffer entirely. The data will never be truncated. The payloadLen will be increased if necessary so the data fits within the payloadLen.
|
inline |
Set a int8_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set an int16_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set an int16_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set an float (4 byte floating point) value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set an double (8 byte floating point) value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set a uint8_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set a uint16_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
|
inline |
Set a uint32_t value at offset in the payload.
| offset | The offset relative to the payload, so 0 is the first byte of the payload |
| value | The value to set |
The data must fit in the underlying buffer or false will be returned if it can't fit in its entirety. A partial value will never be copied. If the new data is larger than the current payloadLen, then the payload size is increased so it will contain the newly set data.
| void UbloxCommandBase::updateChecksum | ( | ) |
When preparing a command to send, updates the checksum, sync, and length bytes.
The length is generated from the payloadLen member variable, which should be correct when using the set or append methods, or after manually setting the length.


Madden: Hello sir, I am a Captain in the British army.
I am in search of a German spy. Have you recently done business with a Chinese man wearing a suit?
Ticket Booth Worker: Yes, Captain, a mysterious fellow of that description just bought a ticket
to the Durham station.


ldd
Display shared library dependencies of a binary.
Do not use on an untrusted binary, use objdump for that instead.
More information: home page
- Display shared library dependencies of a binary:
ldd path/to/binary
- Display all information about dependencies:
ldd --verbose path/to/binary
- Display unused direct dependencies:
ldd --unused path/to/binary
- Report missing data objects and perform data relocations:
ldd --data-relocs path/to/binary
- Report missing data objects and functions, and perform relocations for both:
ldd --function-relocs path/to/binary


google_directions.Rd
The Google Maps Directions API is a service that calculates directions between locations. You can search for directions for several modes of transportation, including transit, driving, walking, or cycling.
google_directions(origin, destination, mode = c("driving", "walking", "bicycling", "transit"), departure_time = NULL, arrival_time = NULL, waypoints = NULL, optimise_waypoints = FALSE, alternatives = FALSE, avoid = NULL, units = c("metric", "imperial"), traffic_model = NULL, transit_mode = NULL, transit_routing_preference = NULL, language = NULL, region = NULL, key = get_api_key("directions"), simplify = TRUE, curl_proxy = NULL)
| origin | Origin location as either a one or two column data.frame, a list of unnamed elements, each element is either a numeric vector of lat/lon coordinates, an address string or a place_id, or a vector of a pair of lat / lon coordinates |
|---|---|
| destination | destination location as either a one or two column data.frame, a list of unnamed elements, each element is either a numeric vector of lat/lon coordinates, an address string or place_id, or a vector of a pair of lat / lon coordinates |
| mode |
|
| departure_time | The desired time of departure.
Use either a |
| arrival_time | Specifies the desired time of arrival for transit requests.
Use either a |
| waypoints | list of waypoints, expressed as either |
| optimise_waypoints |
|
| alternatives |
|
| avoid |
|
| units |
|
| traffic_model |
|
| transit_mode |
|
| transit_routing_preference |
|
| language |
|
| region |
|
| key |
|
| simplify |
|
| curl_proxy | a curl proxy object |
Either list or JSON string of the route between origin and destination
The amount of queries you can make to Google's APIs is dependent on both the service and the API you are using.
Each API has specific quotas and limits. Check Google's API documentation for details.
View your usage at the Google Cloud Console https://console.cloud.google.com/
Each API can only accept and return one request at a time. If you write a loop to make multiple API calls you should ensure you don't go over your quota / limits during the loop.
# NOT RUN { set_key("YOUR_GOOGLE_API_KEY") ## using lat/long coordinates google_directions(origin = c(-37.8179746,<PHONE_NUMBER>), destination = c(-37.81659, 144.9841), mode = "walking") ## using address string google_directions(origin = "Flinders Street Station, Melbourne", destination = "MCG, Melbourne", mode = "walking") google_directions(origin = "Melbourne Airport, Australia", destination = "Portsea, Melbourne, Australia", departure_time = Sys.time() + (24 * 60 * 60), waypoints = list(stop = c(-37.81659, 144.9841), via = "Ringwood, Victoria"), mode = "driving", alternatives = FALSE, avoid = c("TOLLS", "highways"), units = "imperial", simplify = TRUE) ## using 'now' as departure time google_directions(origin = "Flinders Street Station, Melbourne", destination = "MCG, Melbourne", departure_time = 'now') ## waypoints expressed as an encoded polyline polyWaypoints <- encode_pl(tram_stops[1:2, c("stop_lat")], tram_stops[1:2, c("stop_lon")]) polyWaypoints <- list(via = paste0("enc:", polyWaypoints, ":")) google_directions(origin = "Melbourne Zoo, Melbourne", destination = "Studley Park, Melbourne", waypoints = polyWaypoints) ## using bus and less walking res <- google_directions(origin = "Melbourne Airport, Australia", destination = "Portsea, Melbourne, Australia", departure_time = Sys.time() + (24 * 60 * 60), mode = "transit", transit_mode = "bus", transit_routing_preference = "less_walking", simplify = FALSE) ## using arrival time res <- google_directions(origin = "Melbourne Airport, Australia", destination = "Portsea, Melbourne, Australia", arrival_time = Sys.time() + (24 * 60 * 60), mode = "transit", transit_mode = "bus", transit_routing_preference = "less_walking", simplify = FALSE) ## return results in French res <- google_directions(origin = "Melbourne Airport, Australia", destination = "Portsea, Melbourne, Australia", arrival_time = Sys.time() + (24 * 60 * 60), mode = "transit", transit_mode = "bus", transit_routing_preference = "less_walking", language = "fr", simplify = FALSE) # }


Hot Damn!
Get Some
Bone!
Booooone!
Vindication!
Bingpot!

Wuntch insult 4
Is that a talking raisin?
Wuntch insult 5
Wuntch time is over
You're not Cheddar
Holt's robot impression
Dismissed
Dirtbag!
I'd Like to Play
Oopsie Doodle
I am your Superior Officer
Holt forced laughing
I have zero interest in Food
I'm
This is
Raymond Holt
Is everything OK?

 No.
The full bullpen!


{% extends "base.html" %} {% set active_page = "set_donation" %} {% set page_title = "Set Donation - Change your donation amount" %} {% block head %} {% endblock %} {% block body %}
Since there is no registration we use the message signing system built into the QT wallet to prove you control the address. The basic process is:
By default if you do not have an address set for a merge mined coin it will automatically be converted to your account currency ({{ user_currency }}).
You may (optionally) set an address for any coin we mine and you'll be paid out your portion of that rather than exchanging it
Some merge mined coins can't be exchanged so you'll need to set an address for them or they'll be donated to the pool.


Kavala is a large, conspicuous city with a commercial port.
For full details on clearing into our out of Greece see Greek Formalities.
The harbour consists of inner and outer basins. There is rarely room for yachts among the fishing and work boats in the inner harbour. If there is room, check if it is alright to moor in their first. Otherwise, moor on the north quay in the outer harbour. The quay wall is high and getting ashore is not easy (see comments below from MY LeeZe who visited here in 2015). Power and water are available, but limited. The shelter is good, as is the holding in the mud of the harbour bottom.
The yacht club is private with no facilities for visiting yachts. Their berths are painted white.
If seeking shelter, there is a storm anchorage on the far west side of the harbour with good holding.
Last updated July 2015.
The yacht club here is not open to visitors.


Become a BBQ master!
Register Today
BBQ isn't just standing in front of your grill with it on full blast and hoping for the best. It's an art! One way to speed up the process is to learn from the best. You can do just that by signing up for this free webinar!
We'll never share your information without your permission


The central concept for spectral simulations with EasySpin is the spin system. It collects all information about the spins in the sample and how they are coupled. In EasySpin, a spin system is represented by a MATLAB structure (the spin system structure) that contains a series of fields holding this information.
The spin system structure contains all information about the spin system and its spin Hamiltonian. Its fields specify spin quantum numbers, interaction parameters, matrices and tensors, relative orientation angles for these matrices and tensors as well as details about broadenings.
The
spin Hamiltonian is set up in frequency units (MHz, not angular frequencies), so all the energy parameters of the Hamiltonian have to
be given in MHz as well. Hence, for example, the field A
represents in fact the diagonal of the hyperfine coupling tensor divided by the Planck constant, A/h, and not of A. Remember that all angles are in radians, not in degrees.
Spin system structures are used by many EasySpin functions, among them the simulation functions chili (slow-motion EPR), garlic (isotropic EPR), pepper (solid-state EPR), salt (ENDOR) saffron (pulse EPR), and curry (magnetometry).
Before we give a full list of possible fields, here are a couple of examples of spin system definitions. There are two equivalent ways.
Sys.S = 1/2; Sys.g = [1.9 2.0 2.1]; Sys.lw = 0.7; % mT
Sys = struct('S',1/2,'g',[1.9 2.0 2.1],'lw',0.7);
Nuclei can be added to a spin system either using a set of fields (Nucs
, A
) or using the function nucspinadd.
Sys.S = 1/2; Sys.g = [2 2.1 2.2]; Sys.Nucs = '63Cu'; Sys.A = [50 50 460]; % MHzIt is more convenient to use nucspinadd:
Sys = struct('S',1/2,'g',[2 2.1 2.2]); Sys = nucspinadd(Sys,'63Cu',[50 50 460]);
A high-spin Mn2+ system with zero-field splitting is
Sys = struct('S',5/2,'g',2,'Nucs','55Mn'); Sys.A = -240; % MHz Sys.D = 120; % MHz
The following groups of parameters can be specified in the spin system structure:
All interaction matrices and tensors can have arbitrary orientations with respect to a molecule-fixed frame of reference (the so-called molecular frame).
Below we list and describe all possible spin system structure fields containing spin Hamiltonian parameters.
The two fields S
and Nucs
are used to specify the electron and nuclear spins constituting the spin system. Both are optional. If S
is not given, S=1/2
is assumed. If Nucs
is not specified, Nucs=''
is used.
S
Sys.S = 1/2; % one electron spin with S=1/2 Sys.S = 5/2; % an S=5/2 spin Sys.S = [1/2, 1/2]; % two S=1/2 spins Sys.S = [1, 1, 1/2]; % two S=1 spins and one S=1/2 spin
If S
is not given, it is automatically
set to 1/2.
Nucs
Sys.Nucs = '1H'; % one hydrogen Sys.Nucs = '63Cu'; % a 63Cu nucleus Sys.Nucs = '59Co,14N,14N'; % a 59Co and two 14N nuclei
If there are no nuclear spins in the system, don't specify this field or set it to ''
(an empty character array). Nuclei can be added and removed one at a time using nucspinadd and nucspinrmv.
If not a single isotope, but a natural-abundance mixture of isotopes is needed, just omit the mass number. You can also freely mix single isotopes and natural-abundance mixtures in one spin system.
Sys.Nucs = 'Cu'; % natural-abundance mixture of 69% 63Cu and 31% 65Cu Sys.Nucs = 'Cu,14N'; % same as above, plus a pure 14N Sys.Nucs = 'F,C'; % 100% 19F, plus a mixture of 99% 12C and 1% 13C
EasySpin will automatically simulate the spectra of all possible isotopologues (isotopes combinations) and combine them with the appropriate weights. Hyperfine constants and quadrupole couplings are automatically converted between isotopes. The values given by you in the spin system are taken to apply for the most abundant isotope with an appropriate spin (e.g. 63Cu in the case of Cu, 1H for H, 14N of N, 119Sn for Sn).
It is also possible to give custom/enriched isotope mixtures by explicitly giving a list of the mass numbers of all isotopes in parentheses in Nucs
. Additionally, the abundances should be given in Abund
. In the simplest case of one atom, this would be
Sys.Nucs = '(12,13)C'; % for a mixture of 12C and 13C Sys.Abund = [0.3 0.7]; % 30% of 12C, the rest 13C Sys.Nucs = '(1,2)H'; % for a mixture of protons and deuterons Sys.Abund = [0.05 0.95]; % 95% deuterium
In the case of multiple atoms, Abund
should be a cell array with a list of abundances for each atom. For example
Sys.Nucs = '63Cu,(32,33)S'; % 63Cu with enriched 33S Sys.Abund = {1,[0.1,0.9]]; % 100% 63Cu, 10% 32S and 90% 33S
Custom and natural abundance mixtures and single isotopes can be all used at the same time. Any entry for a natural-abundance atom or for a single isotope in Abund
is ignored.
Sys.Nucs = 'Cu,(32,33)S,1H'; % natural Cu with enriched 33S and a pure 1H Sys.Abund = {1,[0.1,0.9],1}; % one way Sys.Abund = {[],[0.1,0.9],[]}; % another way, yieldig the same result
Abund
Nucs
above.
n
Sys.Nucs = '1H,13C'; % one class of 1H and one class of 13C Sys.n = [2 3]; % 2 protons and 3 carbon-13 spins
Sys.n
can be omitted if all nuclei in Sys.Nucs
occur only once.
Important: pepper
does currently not support Sys.n
. If you have multiple equivalent nuclei, you have to enter each separately.
The g matrices/tensors for all electron spins in the system are supplied in two fields:
g
contains either the 3 principal values of the g tensors, or alternatively the full g tensors.
gFrame
contains the Euler angles specifying the orientations of the g tensors relative to the molecular frame.
See also the reference page on the Electron Zeeman interaction.
g
Rhombic: Each row contains the three principal values of the g tensor of one electron spin.
Sys.g = [2 2.05 2.3]; % rhombic g, for one electron spin Sys.g = [2 2.1 2.3; 1.9 1.95 2.01]; % rhombic g, for two electron spins
Axial: For axial g tensors, only two values are needed. The first value is the one perpendicular to the unique axis, and the second is the one parallel to it.
Sys.g = [2.25 2.03]; % axial g, for one electron spin % = [2.25 2.25 2.03] Sys.g = [2.25 2.03; 1.99 1.98]; % axial g, for two electron spins % = [2.25 2.25 2.03; 1.99 1.99 1.98]
Isotropic: If g is isotropic, it is sufficient to give its isotropic value once.
Sys.g = 2.005; % isotropic g, for one electron spin % = [2.005 2.005 2.005] Sys.g = [2.0023; 2.0025]; % isotropic g, for two electron spins % = [2.0023 2.0023 2.0023; 2.0025 2.0025 2.0025]
No value: If no values are given, EasySpin assumes isotropic g values of 2.002319... (see gfree) for all electron spins.
When the principal values of g are given in g
, the orientation of the g tensor can be specified by Euler angles in gFrame
, see below.
As an alternative, it is also possible to give the full 3x3 g tensor in g
. For example
% full g tensor for one electron spin Sys.g = [ 2.003397 -0.000431 -0.000004;... -0.000416 2.003032 -0.000006;... -0.000014 0.000013 2.002237]; % full g tensors for two electron spins Sys.g = [2 0 0; 0 2 0; 0 0 2; 2.1 0 0; 0 2.1 0, 0 0 2.1];
If you give full g tensors, the Euler angles in gFrame
are ignored.
gFrame
gFrame
is assumed to be all-zero, that is, the g tensors of all electron spins are aligned with the molecular frame.
Sys.gFrame = [0 10 0]*pi/180; % one electron spin Sys.gFrame = [0 10 0; 23 -45 67]*pi/180; % two electron spins Sys.gFrame = [0 0 0; 0 pi/4 0; 0 -pi/4 0]; % three electron spins
With these angles, EasySpin can transform a g tensor from its diagonal eigenframe representation to the molecular frame representation. Here is an explicit example how this is done:
gpv = [2.1 1.97 2.04]; % principal values gFrame = [10 34 -2]*pi/180; % Euler angles, in radians R_M2g = erot(gFrame) % transformation matrix g_g = diag(gpv) % g in the g frame g_M = R_M2g.'*g_g*R_M2g % g in molecular frame
which gives the following output
R_M2g = 0.8220 0.1095 -0.5589 -0.1450 0.9892 -0.0195 0.5507 0.0971 0.8290 g_g = 2.1000 0 0 0 1.9700 0 0 0 2.0400 g_M = 2.0791 0.0154 -0.0278 0.0154 1.9722 -0.0023 -0.0278 -0.0023 2.0587
The rows of the transformation matrix R_M2g
correspond to the g tensor principal axes in molecular frame coordinates. The columns, on the other hand, correspond to the molecular axes in g frame coordinates. See the page on frames for more details.
If a 3x3 transformation matrix Rg
is given, e.g. from literature, then the corresponding Euler angles can be obtained by
gFrame = eulang(Rg);
Prior to EasySpin 5, the field gpa
was used instead of gFrame
.
To convert old gpa
values to gFrame
, invert the order and flip the sign of the three Euler angles.
For each electron-nucleus pair, a hyperfine coupling tensor can be specified. The following fields are used.
A
A(k,:)
refers to nuclear spin k
. The orientations of the A matrices are given in AFrame
.
Sys.A = [-6 12 23]; % 1 electron and 1 nucleus Sys.A = [10 10 -20; 30 40 50]; % 1 electron and 2 nuclei
For axial and isotropic hyperfine tensors, the notation can be shortened, just as in the case of the g tensor.
Sys.A = [4 10]; % = [4 4 10] (axial, 1 electron and 1 nucleus) Sys.A = 34; % = [34 34 34] (isotropic, 1 electron and 1 nucleus) Sys.A = [4 10; 1 2]; % = [4 4 10; 1 1 2] (axial, 1 electron and 2 nucleui) Sys.A = [7; 3]; % = [7 7 7; 3 3 3] (isotropic, 1 electron and 2 nuclei)
If the system contains more than one electron spin, each row contains the principal values of the hyperfine couplings to all electron spins, listed one after the other.
Sys.A = [10 10 -20 30 40 50]; % 2 electrons and 1 nucleus Sys.A = [10 10 -20 30 40 50; 1 1 -2 3 4 5]; % 2 electrons and 2 nuclei
It is possible to specify full A matrices in A
. The 3x3 matrices have to be combined like the 1x3 vectors used when only principal values are
defined: For different electrons, put the 3x3 matrices side by side, for different nuclei, on top of each other. If full matrices are given in A
,
AFrame
is ignored.
Sys.A = [5 0 0; 0 5 0; 0 0 5] % 1 electron and 1 nucleus Sys.A = [[5 0 0; 0 5 0; 0 0 5]; [10 0 0; 0 10 0; 0 0 10]] % 1 electron and 2 nuclei Sys.A = [[5 0 0; 0 5 0; 0 0 5], [10 0 0; 0 10 0; 0 0 10]] % 2 electrons and 1 nucleus
A_
A
and A_
cannot be used at the same time.
Sys.A_ = 2; % isotropic component only Sys.A_ = [2 3] % isotropic and axial component Sys.A_ = [2 3 0.4] % isotropic, axial and rhombic componentThe cartesian form (as used in
A
) and the spherical form (as used in A_
) are related by
% spherical -> cartesian A(1) = A_(1)-A_(2)-A_(3); A(2) = A_(1)-A_(2)+A_(3); A(3) = A_(1)+2*A_(2) % cartesian -> spherical A_(1) = mean(A); A_(2) = (2*A(3)-A(1)-A(2))/6; A_(3) = (-A(1)+A(2))/2;or if you prefer more compact notation
A = A_*[1 1 1; -1 -1 2; -1 +1 0]; % spherical -> cartesian A_ = A*[2 -1 -3; 2 -1 3; 2 2 0]/6; % cartesian -> sphericalFor more than one nucleus and more than one electron spin, the array structure is analogous to
A
.
AFrame
gFrame
. If AFrame
is not specified, it is assumed to be all-zero, that is, all tensors are aligned with the molecular frame. See also erot.
Each row of AFrame
contains the three Euler angles for one nucleus.
Sys.AFrame = [0 20 0]*pi/180; % one electron spin, one nucleus Sys.AFrame = [0 0 0; 0 10 90; 12 -30 34]*pi/180 % one electron spin, three nuclei
If there are two or more electron spins, each nucleus has two or more hyperfine tensors, and consequently each row should contain two or more sets of Euler angles.
Sys.AFrame = [0 20 0, 13 -30 80]*pi/180; % 2 electrons, 1 nucleus Sys.AFrame = [0 20 0, 0 0 0; 0 10 0, 0 30 50]*pi/180; % 2 electrons, 2 nuclei
Here is how principal values and angles can be converted to a full matrix:
Apv = [4 9 13]; % principal values, MHz AFrame = [10 45 -30]*pi/180; % Euler angles A_A = diag(Apv); % full matrix in A frame R = erot(AFrame); % transformation matrix A_M = R.'*A_A*R; % full matrix in molecular frame
See the page on frames for more details.
Prior to EasySpin 5, the field Apa
was used instead of AFrame
.
To convert old Apa
values to AFrame
, invert the order and flip the sign of the three Euler angles.
For each nucleus spin, a nuclear quadrupole coupling tensor Q can be given,
using the fields Q
(for the parameters e2qQ/h and η, the principal values, or the full matrix) and QFrame
(for the orientation).
Q
Sys.Q = 0.7 % one nucleus, eeQq/h = 0.7 MHz Sys.Q = [0.7, 1.2] % same for two nuclei
Sys.Q = [1.2 0.29] % one nucleus, eeQq/h = 1.2 MHz and eta = 0.29 Sys.Q = [1.2 0.29; 0.1 0] % same with a second nucleus (second row)
Sys.Q = [-1 -1 2] % one nucleus, Qxx = -1, Qyy = -1, Qzz = +2 MHz Sys.Q = [-1 -1 2; 0.2 0.3 -0.5] % same for two nuclei
Sys.Q = [-1 0 0; 0 -1 0; 0 0 2]*0.1; % for one nucleus, diagonal Sys.Q = [0.125 -0.6495 -1.299; -0.6495 -0.625 0.75; -1.299 0.75 0.5]; % general, one nucleus Q1 = [-0.9 0 0; 0 -1.1 0; 0 0 2]*0.15; Q2 = [-0.7 0 0; 0 -1.3 0; 0 0 2]*0.31; Sys.Q = [Q1; Q2]; % for two nuclei
Here is an example of how to convert from e2Qq/h and η to the three principal Q values:
eeQqh = 1; % MHz eta = 0.2; % unitless I = 1; % nuclear spin must be known! Q = eeQqh/(4*I*(2*I-1)) * [-1+eta, -1-eta, 2]
And here is a demonstration of how to conver from the three principal values of Q to e2Qq/h and η:
Q = [-0.5 -1.0 1.5] % MHz I = 1; % nuclear spin must be known! eeQqh = 2*I*(2*I-1)*Q(3) % MHz eta = (Q(1)-Q(2))/Q(3) % unitless
See also the reference page on the nuclear quadrupole interaction.
QFrame
gFrame
and AFrame
. QFrame
should include one row of three angles for each nucleus. The angles are in units of radians, not degrees.
Sys.QFrame = [0 pi/4 0]; % one nucleus Sys.QFrame = [30 45 0; 10 -30 0]*pi/180; % two nuclei
Here is how principal values and angles can be converted to a full matrix:
Qpv = [-0.9 -1.1 2]*0.125; % principal values, MHz QFrame = [10 45 -30]*pi/180; % Euler angles R = erot(QFrame); % transformation matrix Q_Q = diag(Qpv); % full matrix in Q frame Q_M = R.'*Q_Q*R; % full matrix in molecular frame
See the page on frames for more details.
Prior to EasySpin 5, the field Qpa
was used instead of QFrame
.
To convert old Qpa
values to QFrame
, invert the order and flip the sign of the three Euler angles.
For each electron spin, a zero-field splitting can be specified in the fields D
and DFrame
. See also the reference page on the zero-field interaction.
D
D
gives the zero-field splitting tensors for the electron spins in the spin system. It should be in units of MHz (1 cm-1 = 29979 MHz). It can be specified in several different ways.
Axial: If the zero-field splitting tensor is axial, give the D value for each electron spin. The orientation of the tensor can be specified in the field DFrame
(see below).
Sys.D = [200]; % 1 electron spin, D = 200 MHz Sys.D = [200 -340]; % 2 electron spins, D value each, in MHz Sys.D = [200 -340 1100]; % 3 electron spins, D value each, in MHz
Rhombic: For a zero-field splitting tensor with rhombic asymmetry, give both the D and the E value for each electron spin. The orientation of the tensor can be specified in the field DFrame
(see below).
Sys.D = [200 10]; % 1 electron spin, D = 200 MHz and E = 10 MHz Sys.D = [200 10; 340 90]; % 2 electron spins, D and E value for each spin
Principal values: For both axial and rhombic symmetry, you can give the three principal values of the D tensor. The orientation of the tensor can be specified in the field DFrame
(see below).
Sys.D = [-100 -100 200]; % 1 electron spin, Dx = Dy = -100 MHz, Dz = 200 MHz Sys.D = [-150 -50 200; 450 350 -800]; % 2 electron spinsHere is how the principal values can be computed from D and E
D = 120; E = 15; % D and E parameters, in MHz Sys.D = [-1,-1,2]/3*D + [1,-1,0]*E % conversion to D principal values
It is possible to provide a non-traceless D tensor.
Full matrix: You can also specify the full D matrix for each electron spin. E.g. for one electron spin
Sys.D = [-33.8 -24.1 -122.1; -24.1 -91.2 44.4; -122.1 44.4 125];
It is possible to provide a non-traceless D tensor.
Include zeros for any electron spin with S = 1/2.
DFrame
gFrame
and QFrame
. If absent, it is assumed to be all zeros.
Internally, EasySpin uses the following procedure to compute the full D tensor in the molecular frame from the given principal values and the Euler angles
Dvals = [-25 -55 80]; % principal values DFrame = [10 20 0]*pi/180; % tilt angles D_D = diag(Dvals); % full D tensor in its eigenframe R = erot(DFrame); % rotation matrix D_M = R.'*diag(Dvals)*R; % full D tensor in molecular frame
See the page on frames for more details.
Prior to EasySpin 5, the field Dpa
was used instead of DFrame
.
To convert old Dpa
values to DFrame
, invert the order and flip the sign of the three Euler angles.
EasySpin supports a series of high-order electron spin operators in the spin Hamiltonian.
B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12
Each field that is given should contain a row vector of 2k+1 parameters, in order of decreasing q, running from +k to -k. For example:
Sys.B2 = [0 0 560 0 0]; % B(2,q) with q = +2,+1,0,-1,-2 Sys.B4 = [0 132 0 0 0 0 0 0 0]; % B(4,q) with q = +4,+3,+2,+1,0,-1,-2,-3,-4The only nonzero elements in the above examples are therefore B(2,0) and B(4,+3).
Positive (and zero) q correspond to to the cosine tesseral operators, and negative q correspond to the sine tesseral operators.
In the common case that only the q=0 element is needed for a given k, it can be given alone in an abbreviated syntax.
Sys.B2 = [0 0 99 0 0]; % B(2,0) only, full form Sys.B2 = 99; % equivalent abbreviated form Sys.B4 = [0 0 0 0 -8700 0 0 0 0]; % B(4,0) only, full form Sys.B4 = -8700; % equivalent abbreviated form
If more than one electron spin is present, specify one row of 2k+1 elements for each electron spin. The first row is for the first electron spin, etc.
Sys.S = [5/2 2]; % two spins B20a = 100; % for the first spin B20b = -98; % for the second spin Sys.B2 = [0 0 B20a 0 0; 0 0 B20b 0 0]; % two rows: one row per spin Sys.B2 = [B20a; B20b]; % abbreviated form for two spins: two rows as well
To include tilt angles for Sys.B1
, Sys.B2
, etc, use the fields Sys.B1Frame
, Sys.B2Frame
, etc. See below.
Both Sys.B2
and Sys.D
provide parameters for the rank-2 zero-field splitting term in the spin Hamiltonian. Therefore, only one of the two can be used. The two spin systems Sys1
and Sys2
in the following example give identical Hamiltonians:
D = 1000; % MHz E = D*0.2; % MHz ang = [pi/3 pi/7 pi/11]; % tilt angles Sys1.D = [D E]; Sys1.DFrame = ang; Sys2.B2 = [E 0 D/3 0 0]; Sys2.B2Frame = ang;
In the special case of high-spin 3d5 ions such as Fe(III), Mn(II), and Cr(I) in axially distorted cubic enviroments, the fourth-order terms are often written in terms of the traditional a and F parameters instead of B4. For their definition, see the reference page on high-order operators. EasySpin versions prior to 6 had a dedicated field Sys.aF
for these. Since EasySpin 6, this is no longer supported. Instead, the fourth-order terms should be specified using Sys.B4
and Sys.B4Frame
. Pay attention that the frames for the a and the F term are different.
B1Frame, B2Frame, ..., B12Frame
B1
, B2
, etc. (see above) in the molecular frame. Use B1Frame
for the rank-1 tensor in B1
, B2Frame
for the rank-2 tensor in B2
, and so forth.
These fields are fully analogous to AFrame
(see above). See the page on frames for more details on frames.
Here is an example for rank 2:
Sys.B2 = [0 30 100 0 0]; % in MHz Sys.B2Frame = [0 pi/3 0]; % in radians
For each pair of electron spins, a bilinear coupling matrix (composed of isotropic, anisotropic, and antisymmetric terms) can be given. You can enter it in one of several ways:
Sys.J
, Sys.dip
, and Sys.dvec
.
Sys.ee
(with Sys.eeFrame
).
Sys.ee
.
Except for the last option, give the orientation of the interaction matrices in Sys.eeFrame
.
In addition, it is also possible to specify an isotropic biquadratic exchange coupling for each electron spin pair in Sys.ee2
. This is a type of coupling that is very rare.
J
List of isotropic exchange coupling constants (in MHz), one for each pair of electron spins. The associated spin Hamiltonian is +J S1S2 (not -2J S1S2). Here is an example for a two-spin system:
Sys.S = [3/2 3/2]; % two electron spins Sys.J = J12; % coupling constant, in MHz
For more than two spins, the pairs are ordered lexicographically, for example for a 4-spin system 1-2, 1-3, 1-4, 2-3, 2-4, 3-4.
Sys.S = [1/2 1/2 1/2 1/2]; % four spins Sys.J = [J12 J13 J14 J23 J24 J34]; % six coupling constants, in MHz
To convert from the more traditional unit cm-1 to MHz, use
J_MHz = J_cm*30e3; % cm^-1 to MHz conversion, approximate J_MHz = J_cm*100*clight/1e6; % cm^-1 to MHz conversion, exact
You can use either Sys.J
(together with Sys.dip
and Sys.dvec
if needed) or Sys.ee
(with Sys.eeFrame
), but not both at the same time.
dip
List of values that describe the symmetric part of the coupling between two electron spins (dipolar interaction), in units of MHz. Each row corresponds to one electron-electron pair. It can contain 1, 2, or 3 numbers.
Sys.S = [1/2 1/2]; % two spins % The following two inputs give the same axial dipolar tensor Sys.dip = 23; % axial dipolar coupling, MHz Sys.dip = 23*[1 1 -2]; % principal values of axial dipolar coupling tensor, MHz % The following two inputs give the same rhombic dipolar tensor Sys.dip = [23 3]; % axial and rhombic dipolar coupling, MHz Sys.dip = 23*[1 1 -2] + 3*[1 -1 0]; % principal values of axial dipolar coupling tensor, MHz
The axial and rhombic couplings and the principal values of the dipolar tensor are related via
% axial and rhombic -> principal values dip_pv = dip_axial*[1 1 -2] + dip_rhombic*[1 -1 0]; % principal values -> axial and rhombic dip_rhombic = (dip_pv(1)-dip_pv(2))/2 dip_axial = ((dip_pv(1)+dip_pv(2))/2-dip_pv(3))/3
For more than two spins, specify the couplings for electron pairs in lexicographic order, for example 1-2, 1-3, 2-3 for a three-spin system.
Sys.S = [3/2 3/2 3/2]; % three spins dip12 = 1.4e4; % units: MHz dip23 = 2.1e4; dip13 = 3.7e4; Sys.dip = [dip12; dip13; dip23]; % three tensors
To specify the orientation of the dipolar tensor, use Sys.eeFrame
.
You can use either Sys.dip
(together with Sys.J
and Sys.dvec
if needed) or Sys.ee
, but not both at the same time.
dvec
List of vectors (one per row, in units of MHz) that describe the antisymmetric part of the coupling between two electron spins (Dzyaloshinskii-Moriya interaction). The associated spin Hamiltonian is d12.(S1xS2), where d12 is the interaction vector.
Sys.S = [1/2 1/2]; % two spins d12 = [dx dy dz]; % units: MHz Sys.dvec = d12; % one interaction vector
For more than two spins, the vectors are ordered in lexicographic order, for example 1-2, 1-3, 2-3 for a three-spin system.
Sys.S = [1 1 1]; % three spins d12 = [0 0 1.4e4]; % units: MHz d23 = [0 0 2.1e4]; d13 = [0 0 3.7e4]; Sys.dvec = [d12;d13;d23]; % three interaction vectors, one per row
You can use either Sys.J
(together with Sys.dip
and Sys.dvec
if needed) or Sys.ee
(with Sys.eeFrame
), but not both at the same time.
ee
Principal value of the electron-electron interaction matrices, in MHz.
Each row corresponds to the diagonal of an interaction matrix (in its eigenframe). For two electron spins, ee
contains one row only.
Sys.S = [1/2 1/2]; % two electron spins Sys.ee = [80 80 20]; % principal values of one coupling matrix, MHz
For more than two electron spins, the pairs are lexicographically ordered according to the indices of the electron spins involved. If n is the number of electron spins, there are N = n(n-1)/2 rows. For example, for 4 spins there are 6 rows with the principal values for the interaction of spins 1-2, 1-3, 1-4, 2-3, 2-4, 3-4, in this order.
Sys.S = [1/2 1/2 1/2]; % three spins ee12 = [80 80 20]; ee13 = [10 10 -30]; ee14 = [10 10 -30]; ee23 = [0 0 0]; ee24 = [0 0 0]; ee34 = [80 80 80]; Sys.ee = [ee12; ee13; ee14; ee23; ee24; ee34]; % 6 coupling matrices, MHz
If only isotropic couplings are needed, use Sys.J
(see above).
It is also possible to specify the full 3x3 interaction matrices instead of the 3 principal values and 3 Euler angles. These matrices combine the isotropic, antisymmetric and symmetric parts of the interaction. For a 2-electron system, ee
is a single 3x3 array.
Sys.S = [1/2 1/2]; % two spins Sys.ee = [80 0 0;0 80 0; 0 0 20]; % one coupling matrix, MHz
For more electrons, the 3x3 matrices are stacked on top of each other, to give a 3Nx3 array.
Sys.S = [1/2 1/2 1/2]; % three spins ee12 = [80 0 0; 0 80 0; 0 0 20]; ee13 = diag([10 10 -30]); ee23 = zeros(3); Sys.ee = [ee12; ee13; ee23]; % three coupling matrices
Note that you can use either Sys.ee
or Sys.J
(together with Sys.dip
and Sys.dvec
if needed), but not both at the same time.
eeFrame
ee
) in the molecular frame. Each row contains the Euler angles for the corresponding row in ee
.
This is fully analogous to AFrame
(see above). Check out the page on frames for more details on frames.
Prior to EasySpin 5, the field eepa
was used instead of eeFrame
.
To convert old eepa
values to eeFrame
, invert the order and flip the sign of the three Euler angles.
ee2
ee
.
Sys.S = [3/2 3/2]; % two electron spins Sys.ee2 = 130; % one biquadratic coupling 1-2 Sys.S = [3/2 3/2 3/2]; % three electron spins Sys.ee2 = [130 150 190]; % couplings 1-2, 1-3, 2-3 Sys.S = [1 1 1 1]; % four electron spins Sys.ee2 = [130 0 130 130 0 130]; % couplings 1-2, 1-3, 1-4, 2-3, 2-4, 3-4
EasySpin defines the biquadratic exchange term in the spin Hamiltonian as +j(S1.S2)2, with a plus sign. In the literature, it is sometimes defined with a negative sign, so be careful when using literature values.
Chemical shielding/shift (CS) tensors for all nuclei in the spin system can be specified in the field Sys.sigma
, with the orientation in Sys.sigmaFrame
.
In EPR spectroscopy practice, the typically very small deviations of the shielding tensor from the identity matrix are never detectable. The field can be used for numerical investigations. Also, Sys.sigma
can be used to emulate the effective pseudo-nuclear "effect" that has been used to describe hyperfine spectra of high-spin systems in an effective-spin picture.
sigma
Principal values of the CS tensors, or full CS tensors. When providing principal values, each row contains the three principal values of one CS tensor.
Sys.Nucs = '1H'; % one nuclear spin Sys.sigma = 1-[4 5 9]*1e-6; % principal values of shielding tensor
sigmaFrame
Array containing the Euler angles describing the orientation of the chemical shielding tensors (specified in sigma
) in the molecular frame. Each row contains the three Euler angles for the corresponding row in sigma
.
This is fully analogous to eeFrame
(see above). Check out the page on frames for more details on frames.
For each pair of nuclear spins, a bilinear coupling matrix (composed of isotropic, anisotropic, and antisymmetric terms) can be given. This term is specified in the field Sys.nn
, with the orientation in Sys.nnFrame
.
In practice, this term is essentially always too small to be of any relevance for EPR or ENDOR spectra. EasySpin provides it so its effects on spectra can be explored.
nn
Principal values of the nucleus-nucleus interaction matrices, or full interaction matrices, in MHz. For providing principal values, each row contains the three principal values of one interaction matrix. For two nuclear spins, nn
contains one row only.
Sys.Nucs = '1H,1H'; % two nuclear spins Sys.nn = [10 20 30]*1e-6; % principal values of coupling matrix between spins 1 and 2, MHz
For more than two nuclear spins, the pairs are lexicographically ordered according to the indices of the nuclear spins involved. If n is the number of nuclear spins, there are N = n(n-1)/2 rows. For example, for 4 spins there are 6 rows with the principal values for the interaction of spins 1-2, 1-3, 1-4, 2-3, 2-4, 3-4, in this order.
Sys.Nucs = '1H,1H,19F'; % three spins nn12 = [50 50 100]*1e-6; nn13 = [10 10 -30]*1e-6; nn14 = [10 10 -30]*1e-6; nn23 = [0 0 0]; nn24 = [0 0 0]; nn34 = [80 80 80]*1e-6; Sys.nn = [nn12; nn13; nn14; nn23; nn24; nn34]; % 6 coupling matrices, MHz
If the principal values are given, the orientation of the interaction matrices can be specified via Euler angles in the field nnFrame
(see below).
It is also possible to specify the full 3x3 interaction matrices instead of the 3 principal values and 3 Euler angles. For two nuclei, nn
is a single 3x3 array.
Sys.Nucs = '1H,1H'; % two nuclear spins Sys.nn = [50 0 0;0 50 0; 0 0 100]*1e-6; % one coupling matrix, MHz
For more nuclei, the 3x3 matrices are stacked on top of each other, to give a 3Nx3 array.
Sys.S = '1H,1H,1H'; % three spins nn12 = [50 0 0; 0 50 0; 0 0 100]*1e-6; nn13 = diag([10 10 -30])*1e-6; nn23 = zeros(3); Sys.nn = [nn12; nn13; nn23]; % three coupling matrices, MHz
nnFrame
Array containing the Euler angles describing the orientation of the nucleus-nucleus interaction matrices (specified in nn
) in the molecular frame. Each row contains the three Euler angles for the corresponding row in nn
.
This is fully analogous to eeFrame
(see above). Check out the page on frames for more details on frames.
L
. Spin-orbit coupling is specified via the fields soc
(coupling strength) and orf
(orbital reduction factor). Orbital angular momenta are supported by the simulation functions pepper (solid-state EPR) and curry (magnetometry).
L
L
is an optional field. If given, it must have the same number of entries as S
and the entries have to be nonnegative integers. The kth orbital angular momentum is coupled to the kth spin angular momentum. Examples:
% one spin 1 associated to a L = 3 Sys.S = 1; Sys.L = 3; % two spin-1/2, each associated to L = 2 Sys.S = [1/2 1/2]; Sys.L = [2 2]; % one spin-1/2 without L and a spin 3/2 with L = 1 Sys.S = [1/2 3/2]; Sys.L = [0 1];
CF0, CF2, CF4, CF6, CF8, CF10, CF12
CF2
is for k = 2, and CF4
is k = 4. If any of these fields is not given, it is treated as zero. L
must be given, otherwise the CF are ignored.
Each field that is given should contain a row vector of 2k+1 parameters, in order of decreasing q, running from +k to -k. For example:
Sys.CF2 = [0 0 560 0 0]; % CF(2,q) with q = +2,+1,0,-1,-2 Sys.CF4 = [0 132 0 0 0 0 0 0 0]; % CF(4,q) with q = +4,+3,+2,+1,0,-1,-2,-3,-4The only nonzero elements in the above examples are therefore CF(2,0) and CF(4,+3).
In the common case that only the q=0 element is needed for a given k, it can be given alone in an abbreviated syntax valid for any k.
Sys.CF2 = [0 0 99 0 0]; % CF(2,0) only, full form Sys.CF2 = 99; % equivalent abbreviated form Sys.CF4 = [0 0 0 0 -8700 0 0 0 0]; % CF(4,0) only, full form Sys.CF4 = -8700; % equivalent abbreviated form
If more than one electron spin (and therefore more than one orbital angular moment) is present, specify one row of 2k+1 elements for each orbital angular moment. The first row is for the first orbital angular moment, etc.
Sys.S = [5/2 2]; % two spins Sys.L = [1 2]; % with two orbital angular momenta CF20a = 100; % for the first orbital angular moment CF20b = -98; % for the second orbital angular moment Sys.CF2 = [0 0 CF20a 0 0; 0 0 CF20b 0 0]; % two rows: one row per orbital angular moment Sys.CF2 = [CF20a; CF20b]; % abbreviated form for two orbital angular moment, two rows as well
Currently, it is not possible to include tilt angles for the principal frames of these crystal field interaction tensors. All of them are assumed to be collinear with the molecular frame. By changing the molecular frame, i.e. by tilting all other tensors (g, A, etc), this limitation can be partially circumvented. Still, all the crystal-field interactions are collinear. Alternatively, you can use wignerd
to compute a Wigner rotation matrix that can be used to tilt the tensors explicitly.
angles = rand(1,3)*pi; % Euler tilt angles, in radians CF2 = [3 4 5 0 2]; % CF(2,q) tensor components R = wignerd(2,angles); % rotation matrix for rank-2 tensor CF2 = R*CF2; % rotated tensor Sys.CF2 = CF2.';
orf
L
. orf
is an optional field, if omitted it is assumed equal to 1 for all orbital angular momenta. The number of elements in orf
must match the number of elements in L
.
Sys.orf = 3/2; % orf for a single orbital angular momentum Sys.orf = [0.97 0.93]; % orf for two orbital angular momenta
soc
% three electron spins, with linear soc parameter of 170, 250 cm^-1 and 0: Sys.soc = [170; 250; 0]*clight*1e-4; % as above, plus the first spin has a cubic soc parameter of 10 cm-^1: Sys.soc = [170 0, 10; 250, 0, 0; 0, 0, 0]*clight*1e-4; % two electron spin with S =1/2 and 1 and L = 2 and 1 Sys.S = [1/2 1]; Sys.L = [2 1]; Sys.soc = [200; 100]*clight*1e-4; % linear soc of 200 cm-1 between S = 1/2 and L = 2 % linear soc of 100 cm-1 parameter between S = 1 and L = 1
The Spin-Hamiltonian is in general a polynom of the magnetic field and the spin operator. This general expansion is implemented for electron spins (not for nuclei). Currently, general parameter are supported by the simulation functions pepper (solid-state EPR)and curry. The coefficients can be provided in the following way:
Ham
Sys.Ham134 = [0 0 36 0 0 0 12 0 0 0]; % pB = 1, pS = 3, p = 4, q = +4,+3,+2,+1,0,-1,-2,-3,-4
%convert the more common D and E: Sys.Ham022 = [sqrt(2)*E 0 sqrt(2/3)*D 0 0]; %convert an isotropic g value: Sys.Ham110 = -bmagn/planck*1e-9*sqrt(3)*g;
There is a number of fields by which line broadenings can be specified. lw
and lwEndor
are line widths (FWHM) which are used for convolution of the simulated spectrum. All others are so-called strains and describe Gaussian distributions in the associated spin Hamiltonian parameters.
For a full documentation of the line broadening fields in the spin system structure, see the page on line broadenings.
Specify non-equilibrium populations in Sys.Pop
. For a spin system with N
electron states (e.g. 4 for a biradical, 3 for a triplet state), it must be a vector with N
elements giving the populations of the zero-field electron states, from lowest to highest in energy.
E.g., if Sys.Pop = [0.85 0.95 1.2]
for a triplet system (S=1), the population of the lowest-energy zero-field state has a population of 0.85, the middle one has 0.95, and the highest-energy zero-field state has a population of 1.2. If there are coupled nuclei, the populations of all nuclear sublevels within each electron spin manifold are assumed to be equal.
If Sys.Pop
is given, the temperature specified in Exp.Temperature
is ignored.
For examples of spin-polarized systems (ISC triplets, recombination triplets), see the user guide on spin-polarized systems.


Helping to do our part. Each and every day.
The Miami University colony of Theta Tau has become known for our service to our school, university, and the larger Ohio community. We develop and nurture engineers with strong communication, problem-solving, collaboration, and leadership skills that we demonstrate in our profession, our community, and in our lives.


Teaching clojure
The Setup
I had the opportunity recently to teach the clojure programming language to a group of interns. I was consulting for a client who wanted to build a team of clojure developers to maintain and extend an application he had commissioned earlier from a small consultancy. I agreed to train and lead a team until we felt they were “safe without the training wheels”.
This was during the start of the COVID pandemic, so the entire course was held remotely, via Zoom meetings, during six weeks, with two classes of two hours each per week. Thus 12 lessons, totalling 24 hours of classes. I expected the students to spend about two hours for each hour of course work, so they ended up having to work at least 12 hours per week. (I was told later that they had, in fact, had to work quite a bit more than what I had anticipated).
The students (there were four of them) were highly motivated; this training was part of a recruitment effort, and two of them would most likely be hired at the end of the training; so the classes doubled as an extended evaluation period. I felt comfortable with this as this was all explained up front to the students, who got a chance to get “free training from an expert”, during a period where they could not be employed anyhow.
What they learned
I rushed madly trying to prepare training materials, which were heavily based on the excellent online book Clojure for the Brave and True and the clojure Koans. I had already had a chance to review the application they would be maintaining, and so knew that they would also to know clojurescript and the most excellent re-frame front end framework. This meant a lot of material to cover, and I knew that just simple, abstract exercises would not provide sufficient complexity to get a flavour for “real” clojure programming, so I resolved quite early on that the final outcome of the classes would be the delivery of a small, but complete, web based application which would be a clone of the New York Times Spelling Bee word game.
What I learned
Teaching is hard work. I guess I knew this; having run away from a potential teaching career early on1 but I ended up mentoring quite a number of young colleagues throughout my career, and found great satisfaction in seeing them grow. I guess the distinction is the degree of motivation of the student, and the intensity of focus.
Teaching clojure (and lisps in general) is deceptive: on the one hand, the basic syntax of the language is so simple and easy to learn that the student gets a sense of false confidence in their progress; on the other hand, the tooling is unfamiliar (and somewhat unpolished) adding a degree of unnecessary complexity.
Once the initial hurdle was over, and we were able to dive into code and exercises, the next sticking point was definitely trying to understand functional idioms. None of my students had been exposed to the ideas behind functional programming at University.2 This did not greatly improve my opinion of current CS and software engineering programs… The students had familiarity with the following languages: Python, Java, C# and a little C++. These are all language from the same “family”, and follow largely an object oriented, mutable in place approach to software design. Getting the students to think outside of this particular box was challenging, but rewarding.
One aspect which surprised me, though it perhaps shouldn’t have, is that one of the most valuable teaching aspect was the detailed code review and criticism I gave back the students to all of their exercises. One student wrote, giving feedback at the end of the course:
The biggest thing I found helpful in this course would definitely be the code review. It really helps us improve our mindset and as programmers.
Where I was basically taking them through a process analogous to what I normally follow with junior colleagues; i.e. extensive coding review emphasising not only correctness, but style, layout, design, and, what for lack of a better word I call good taste, my students had never had such feedback on their code. Their previous experience was submitting software to some automated test runner which ran their code, and getting a passing grade as soon as the code ran as specified in the assignment. So the greatest missing piece for them was probably the realisation that having the code simply working was by no means enough; the aim was to write understandable code.
So, whereas universities are trying to “teach what industry wants” by using what they think are “popular” languages, they actually fail to instil some of the more important lessons about maintainability and good taste.
In the end, this was most clearly exemplified by another comment from one of my students, who said:
I think I’ve learnt more about programming through this 45 day course than in my degree.
Outcome
I was pleasantly surprised that all of my students succeeded in delivering a fully working clone of the spelling bee puzzle (albeit with hard-coded data, so no automatic puzzle generation)
The students actually became very collegial and helpful towards one another, even though they were effectively in competition with one another.
The best thing to come of of this for me was that one of the students who was “cut” from the group eventually managed to convince my client to hire him anyway, so we ended up with a team of three instead of two, and he ended up being an excellent hire, so I think we really lucked out.
I am, as of this writing, still engaged with this client and continue to teach them, now as temporary acting CTO and tech lead, and will have truly succeeded when I have managed to make myself redundant, and they can fully take over the maintenance and future development of the application!


PA Chart of Accounts 1200 SPECIAL PROGRAMS – ELEMENTARY / SECONDARY Activities designed primarily for students having special needs. The Special Programs include support classes for pre-kindergarten, kindergarten, elementary, and secondary students identified as exceptional. (Record expenditures to the following sub-accounts.)
| {{comparisons.fiscalYears[key]}} | |
|---|---|
| {{district.district.name}} | {{district.metricsByFiscalYear[key].metrics['SpecialEducation1200PercentageCost'].value | number: '1.0-0'}} |


{{- partial "head.html" . -}}
{{- partial "header.html" . -}}
{{- partial "hero.html" . -}}
{{ range .Pages }}
{{.Title}}
What is next?
Explorer
{{ end }}
{{- partial "footer.html" . -}}


Director Michael Winterbottom's "Welcome to Sarajevo" is a rancid and self-righteous film that reflects the pro-interventionist outlook of the "laptop bombardiers." During the civil war in former Yugoslavia, this group, which included such notables as NY Times editorialist Anthony Lewis and cultural critic Susan Sontag, advocated NATO bombing of the Bosnian Serbs. In their moral calculus, the Muslims stood for European Jewry in the late 1930s, while the Serbs were the moral and political equivalent of Hitler's executioners.
Frank Boyce bases his screenplay on British journalist Michael Nicolson's "Natasha's Story," an account of his attempt to adopt a Bosnian child. He seeks to spirit her out of Sarajevo to England where he can provide a pleasant life for her in his comfortable home. This story is supposed to lift our spirits and make us believe that there is one good human being left on earth. Stephen Dillane plays the saintly British journalist, whom we encounter in opening scenes as a prototypical cynical Western television reporter trying to come up with lurid footage of urban battle casualties. The reporters in Sarajevo send back footage like this to their studios each day. Their job is to provide the sort of visceral shock on the evening world report that stories about tenement fires and auto crashes provide for local news coverage. Woody Harrelson plays Flynn, a star American journalist who has a daredevil attitude toward street fighting. As long as there is gripping footage to be shot, the hard-drinking Flynn will dodge bullets and be there first. Now that the film has established cynical, risk-taking, hard-drinking reporters as the central male characters, one wonders where it can drift next in an ocean of clich=E9.
The answer to this question is Nina (Marisa Tomei), the head of an orphanage, and Emira (Emira Nusevic), the fetching young orphan girl he decides to rescue from the hell of Sarajevo. Nina is everything that the reporters are not: idealistic, selfless and pure. Which is to say that she is as lacking in complexity as they are. Emira reminds one of the sort of children who used to pop up in Hollywood war movies in the 1950s. These adorable Italian or Korean war orphans are adopted by some grizzled, war-weary American infantry company after begging for a chocolate bar. Aldo Ray would play the Sergeant while Dana Andrews would be cast as the Lieutenant. The children, according to formula, are never German or Japanese. That would not be marketable.
The Bosnian Serbs, according to the formula of 1950's war movies, are Terminators put on earth to kill innocent people. God only knows why. They are ruthless killing machines whom any reasonable, humane person would like to see destroyed by a NATO bomb. The film version of the British journalist at one point confesses to a Bosnian Muslim that he feels shame over the failure of his government to bomb the Serbs into oblivion.
To prove how inhuman the Serbs are, the film includes a horrifying scene. A bus carrying the orphaned children out of Sarajevo into the safety of Italy is stopped at gun-point by ranting Serb soldiers. They board the bus and take Muslim babies with them, presumably to be barbecued and eaten later. It is astonishing that "Welcome to Sarajevo" puts forward the notion that the Serb army would exterminate innocent children in this manner. The real crime of "ethnic cleansing" was beastly enough, but it was designed to carve out pieces of Bosnian territory in order to exclude one ethnic group or another, not exterminate them. While the Serbs were certainly more aggressive than the Muslims, both sides took part in the blood-letting.
A much more powerful scene would have dramatized how Muslim and Serbian villagers, who lived peacefully for generations, came to the boiling point and eventually decided to destroy each other. This was not the agenda of the film-makers who were more interested in a good-versus-evil scenario rather than the complexities of the Yugoslavia tragedy. The production notes indicate how little the film's creators understood about Yugoslavian history. It blames the war on "rivalries between the Serbian, Croatian and Muslim communities in the region" that "go back centuries."
Catherine Samary observes in "Yugoslavia Dismembered" (Monthly Review, 1995) that peace between various ethnic groups was possible when there was economic well-being:
"The periods of Yugoslavia's or Bosnia-Herzegovina's greatest cohesion corresponded to the times when the populations concerned experienced real gains in living standards and rights. It was by contrast threats to those gains during the 1980s--not interethnic hatred--that gave rise to Yugoslavia's fragmentation. The socioeconomic and political crisis of the 1980s was in this respect a turning point."
The author of "Natasha's Story" and the director and screenwriter of "Welcome to Sarajevo" are not interested in this history of real human beings. All of Bosnia is simply a backdrop for the narcissistic display of the British journalist who wants to prove to the world that he is better than everybody. In a scene that reveals his inability to empathize with the people of Yugoslavia, he confronts the mother of the child he seeks to adopt. She is a cigarette-smoking, slatternly woman who nobody in their right mind would want to put in custody of a child. She has one final phone conversation with her daughter, who is safe and happy in England, and the two fail to communicate. Her daughter says that she never wants to come back to Sarajevo again.
This spells victory for the British journalist, who was anxious that the mother would regain custody of the child. He is everything that the unfortunate Yugoslavians are not. He is clean, tobacco-free and sensible. They, on the other hand, are violent, self-destructive and irrational chain-smokers. Why can't everybody get a proper public school education like the protagonist and learn proper, civilized values. This is the rankest sort of hypocrisy. It was the United States, England and other European powers that brought down poor Yugoslavia, awash in debt in the 1980s, just as they are bringing down Thailand and Malaysia today.
Someday there might be a film about the tragic civil war in former Yugoslavia that will probe the causes of the horrible destruction of life and property. It certainly can't come from writers and directors who are cocksure of their "civilizing" mandate. Fortunately, NATO bombers never got involved in the civil war. If they did, it is entirely possible that the war would have spilled beyond the borders of Yugoslavia and involved the former Soviet Union in the fighting. As "Welcome to Sarajevo" appears several years after the conclusion of the war, it lacks the propaganda power to spark intensified fighting. As politics, it is retrograde. As film, it is cliché. This is a movie to avoid.
Louis Proyect
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


I worked with The Perfect Rug to redesign their e-commerce site. I focused on making it mobile responsive, as well as on reducing clutter and making the site easier to use. As part of my work, I ended up redesigning all the key experiences, such as search, customization, and checkout. I also refreshed their branding and made the product more appealing.
At first glance, I noticed that the existing site offered a wide variety of rugs, with a lot of customization options. However, the interaction flows were not streamlined and the overall experience was not optimized. In addition, the mobile version of the site was also hard to use and needed a redesign.
After reviewing the different functions of the site and talking to the team, I was able to deduce two primary personas that were targeted. The Perfect Rug focused on people that were buying rugs for their home. They were interested in highly customizable rugs that would fit their needs. The site also targeted interior designers that were trying to discover and pick rugs for their clients. Both personas had to be considered as I was gearing up for the redesign.
In order to get a deeper understanding of the product and to identify problem areas, I conducted a UX audit. My analysis showed that the site's design was dated, and the interaction model was complicated and at times confusing. I also noticed that the flow from searching for rug, to customizing it and then checking out is complex and has a lot of steps. On the bright side, I noticed that the site has a lot of interesting options for purchasing and customizing rugs.
Next, I conducted a competitive analysis to get an idea of what else is out there, and what might be some areas where competitors are better positioned than The Perfect Rug. I analyzed online rug stores, as well as other popular e-commerce sites. I observed that other sites had simpler navigations and more useful search functions. I also noticed that the average product detail page was simple than the one we had. The competitive analysis was useful in pointing me towards areas that can be improved, as well as understanding where the competition was.
To see how the site was being used, I analyzed its Google Analytics data. I learned that there are a number of pages and functions that were seldomly used and didn't seem to add a lot of value to customers. I was also able to identify key interaction flow and learn how customers navigated the site as they were using the site to find and purchase rugs. I took note of the learnings and would later use them to help inform me when deciding which pages to remove or change.
After I presented all my research findings to the team and got their feedback, I identified the problems that I wanted to tackle. I proceeded with brainstorming potential solutions, which I turned into wireframes. Then, I validated those with the team and got feedback. After a few rounds of iteration, I was able to align with the team on direction going forward.
As I moved to higher-fidelity prototyping, I came up with a visual language for the redesign. I started with the existing branding, but also refined and adjusted it for better aesthetics and visual appeal. Since the site was focusing on shoppers of high-end custom rugs, I focused on making the brand more sophisticated and stylish. I also focused on adding a softer and more human feel to the brand.
Finally, I created high-fidelity designs that included much streamlined interactions, ease of use, and full mobile responsiveness. To do that, I had to greatly simplify the main navigation, search, product pages, as well as checkout process. The client was very pleased with the final result and I worked with the engineering team to get it implemented in the product.


Custom element ProgressBar can be displayed either horizontally or vertically. By setting its "layout" property to "reverse", the layout of the widget's UI elements will be reversed.
Default Layout
Reversed Layout


| 003:185 Khan | : |
Everyone shall taste death. And only on the Day of Resurrection shall you be paid your wages in full. And whoever is removed away from the Fire and admitted to Paradise, he indeed is successful. The life of this world is only the enjoyment of deception (a deceiving thing). |
| 003:185 Maulana | : |
Every soul will taste of death.  Then whoever is removed far from the Fire and is made to enter the Garden, he indeed attains the object. And the life of this world is nothing but a provision of vanities. |
| 003:185 Pickthal | : |
Every soul will taste of death. And ye will be paid on the Day of Resurrection only that which ye have fairly earned. Whoso is removed from the Fire and is made to enter paradise, he indeed is triumphant. The life of this world is but comfort of illusion. |
| 003:185 Rashad | : |
Every person tastes death, then you receive your recompense on the Day of Resurrection. Whoever misses Hell, barely, and makes it to Paradise, has attained a great triumph. The life of this world is no more than an illusion. |
| 003:185 Sarwar | : |
Every soul is destined to experience the agony of death. You (Muslims) will receive the recompense for your deeds on the Day of Judgment. To be saved from the fire and admitted to Paradise is certainly a great triumph.  And you shall be paid in full your rewards only on the Day of Resurrection. So whosoever is removed away from the Fire and is made to enter Heaven has indeed attained his goal. And the life of this world is nothing but an illusory enjoyment. |
| 003:185 Yusufali | : |
Every soul shall have a taste of death: And only on the Day of Judgment shall you be paid your full recompense. Only he who is saved far from the Fire and admitted to the Garden will have attained the object (of Life): For the life of this world is but goods and chattels of deception. |
Concepts/Themes Covered: الإيمان > اليوم الآخر > تفضيل الآخرة على الدنيا Faith> The Hereafter> Prefering the World to the Hereafter الإيمان > اليوم الآخر > الموت > قضاء محتوم Faith> The Hereafter> Death> Decided Judgment الإنسان والعلاقات الأخلاقية > الأخلاق الذميمة > الغرور Man and The Moral Relations>The Dispraised Morals>Pride
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


Alternative: acquiring iwant bootstrapper by using svn:externals
If your project uses svn as version control, a handy way of avoiding having to commit the iwant bootstrapper to the user's svn repository is to link it using svn:externals.
Let's create a local svn repository and check it out.
~ $ svnadmin create svn-repo
~ $ svn co "file://$(readlink -f svn-repo)" iwant-tutorial
Checked out revision 0.
~ $ cd iwant-tutorial
Here we use a shell oneliner to define the svn:externals url. You may want to use the interactive svn pe command.
~/iwant-tutorial $ mkdir as-iwant-tutorial-developer
~/iwant-tutorial $ svn add as-iwant-tutorial-developer
A as-iwant-tutorial-developer
~/iwant-tutorial $ echo '-r 905 https://svn.code.sf.net/p/iwant/code/trunk/essential/iwant-entry/as-some-developer/with with' | svn ps svn:externals --file - as-iwant-tutorial-developer
property 'svn:externals' set on 'as-iwant-tutorial-developer'
A commit and update is needed for svn to fetch the external bootstrapper.
~/iwant-tutorial $ svn commit -m 'external iwant bootstrapper'
Adding as-iwant-tutorial-developer
Committing transaction...
Committed revision 1.
Output asserted
~/iwant-tutorial $ svn up
Updating '.':

At revision 1.
Output asserted
Now we can start using the bootstrapper normally.
~/iwant-tutorial $ as-iwant-tutorial-developer/with/bash/iwant/help.sh
I created /home/hacker/iwant-tutorial/as-iwant-tutorial-developer/i-have/conf/iwant-from
Please edit and uncomment the properties in it and rerun me.
Output asserted


Laying out UI quickly and consistently.
Canopy is designed using a soft 8 pixel grid system to ensure consistency and layout of UI components as well as facilitate typographic order and rhythm.
Using a grid is important in design to maintain consistency in the complex system, saves design and build time by eliminating decisions, and the 8 pixel measurement is used in all popular screen sizes and resolutions so it's a natural fit for any device.
A few technical details before we dive into the grid system itself.
The space between objects on the page are just as important as the object's content. Web based software products are built using HTML and CSS and that negative space is created using "The Box Model". The box model consists of four components starting from the outside moving inward: Margin, Border, Padding, and the object.
This adjustable space is the outermost space of the object that neighbors other objects.
Around the edges of any object is the border. This stroke is highly adjustable and most design tools allow the user to select an outer, inner or centered border so be aware of border settings and other spacing options when designing.
The padding of an object is the space between the object contents itself and the border.
All of these spacing components can be used in conjunction with each other to create directional space between the collection of objects on a page.
We use the terms "pixel" (px) and "point" (pt) interchangeably. A point is simply a measure of space that is dependent of screen resolution. Basically @1x resolution: 1pt = 1px.
The trick part is at higher resolutions (Retina displays etc.). At a @2x: 1pt = 4px due to the fact that resolution doubled on both X and Y axes making each pt 2px wide and 2px tall. You simple multiple this out for each higher resolution (@3x: 1pt = 9px).
All Canopy designs should be designed @1x (at a baseline 1px grid) so that designs can easily be scaled to other screen resolutions. Many design tools (Sketch, Figma, etc.) allow you to export a @1px design to any screen resolution needed.
Simply use multiples of 8 to define all spacing, widths, heights, margins, font size, line height, or any measurable dimension of an object.
We use what is called a "soft grid", meaning the individual elements are positioned relative to each other. This is different from a "hard grid" where elements are placed relative to the larger container.
Use of the soft grid has a few benefits; allows for freedom of movement and it's less restrictive by nature, also when it comes time to code up the UI the grid basically becomes irrelevant. The hard grid method requires more design and coding overhead to get working with it. Simply ensuring that your spacing is set to multiples of 8 can quickly go along way to making the U layout clean and consistent.


"Mr. Chelsea? I am also Mr. Porto and Mr. Real Madrid"
by BeSoccerNew Tottenham coach, Jose Mourinho, was presented to the London team and was questioned about his 'Spurs' phrase when he was Chelsea manager, but he also sent a caring message to Mauricio Pochettino.
"I come with a bit of sadness for his exit. Pochettino can come when he wants. When he misses the players, when he misses the people he works with. The door is always open for him.” He will find another great club and will have a great future," he explained.
Mourinho told reporters that he had a good break: "I was a little lost, but I did well. I even learned to be an expert on television."
Regarding his phrase ("I would never coach Tottenham")m Mourinho stated that he said this "before being fired" from Chelsea. "Mr. Chelsea? I am Mr. Porto and Mr. Real Madrid and other clubs as well, I am whatever club I am at", he said.
Moreover, he analysed his competitive gene and didn't blame anybody for his failures. "If you are happy by losing football matches, it’s difficult to be a winner in any moment of your career. I was always humble but it was in my way. The problem was that you didn’t understand that", he stated.
Featured links
- BREAKING NEWS: Mourinho replaces Pochettino at Tottenham
- The latest football transfers news and rumours
- Wales, golf, Madrid... in that order
- Luis Enrique returns to Spain national team
"I tried to sign Tottenham players in the past. Now, I came here because of them, for the project. I will try to add details, and sometimes details can make the difference.The style of play must be adaptive to the club culture and also the players," The Portuguese declared.
Finally, the Tottenham coach confirmed that "the best gift are the players who are in the squad," referring to possible additions that could take place in winter.


Your username and password didn't match. Please try again.
{% endif %}
{% if not user.is_authenticated %}
To get started on Courselets fast and keep your work secure, we suggest you sign-in with one of your existing social media accounts. Sign in with:
{% endif %}
{% include "psa/social_backends.html" %}
{% if not user.is_authenticated %}
Alternatively, you can try out Courselets without signing in. If you want to access your work in the future (or from another computer), we can email you an access link. To get started, just enter your email address (we'll keep it safe from spammers):
{% endif %}
{% include "psa/legacy_backends.html" %}
Alternatively, if you already have a Courselets.org password, you can sign in here:
{% if DEBUG %}
{% include "psa/user_details.html" %}
{% endif %}
{% endblock %}


{% from 'products/includes/topic_macros.html' import help_topics %} {% from 'includes/common_macros.html' import featured_articles, scam_banner %} {% macro select_product(products) -%}
{{ product.subtitle }}
{{ _('This information gives details about the internal workings of your browser that will help in answering your question.') }}


phcfM is an R package for modelling anthropogenic deforestation. It was initially developed to obtain REDD+ baseline scenarios of deforestation for the "programme holistique de conservation des forets a Madagascar" (from which the package is named after). Parameter inference is done in a hierarchical Bayesian framework. Markov chains Monte Carlo (MCMC) are coded in C++ using the Scythe statistical library to maximize computation efficiency.
| Version: | 1.2 |
| Depends: | coda |
| Published: | 2013-04-09 |
| Author: | Ghislain Vieilledent |
| Maintainer: | Ghislain Vieilledent <ghislain.vieilledent at cirad.fr> |
| License: | GPL-3 | file LICENSE |
| URL: | http://phcfM.sf.net |
| NeedsCompilation: | yes |
| Materials: | README |
| CRAN checks: | phcfM results |
| Reference manual: | phcfM.pdf |
| Package source: | phcfM_1.2.tar.gz |
| Windows binaries: | r-devel: phcfM_1.2.zip, r-release: phcfM_1.2.zip, r-oldrel: phcfM_1.2.zip |
| OS X binaries: | r-release: phcfM_1.2.tgz, r-oldrel: phcfM_1.2.tgz |
| Old sources: | phcfM archive |
Please use the canonical form https://CRAN.R-project.org/package=phcfM to link to this page.


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
Cooking lamb in hay gives it a delightfully earthy and smoky taste. Buy clean hay from a pet shop or garden centre.
For the boulangère potatoes, preheat the oven to 160C/325F/Gas 2.
Heat a heavy-based pan, add some oil, then add the sliced onion, leek, fennel, garlic, thyme, fennel seeds and fry for 3-4 minutes.
Meanwhile, bring the stock to the boil in a saucepan and grease a small ovenproof dish with a little of the butter.
Slice the potatoes thinly on a mandoline and start to layer up the dish with alternating layers of potato and the onion mixture, seasoning with salt and freshly ground black pepper in between.
For the final layer, arrange the potatoes in a neat layer and pour over the hot stock.
Add a couple of knobs of butter, cover with foil and bake for one hour. Remove the foil and cook for another 30 minutes, or until cooked and crisp.
For the lamb, turn the oven up to 200C/400F/Gas 6.
Heat a dash of olive oil in a cocotte (a cast iron casserole dish with a lid) placed over a stove top and brown the lamb all over. Remove the lamb from the cocotte.
Add the hay and a little more oil, just until the hay starts to smoke, then place the lamb on top and cover with the lid.
Bake in the oven for 12-15 minutes, or until the lamb is pink.
To serve, remove the lamb from the hay, rest for 5-10 minutes, then carve and serve with the boulangère potatoes.


Twins’ Baldelli tops Yanks’ Boone for AL Manager of the Ye
by JAKE SEINERNEW YORK (AP) - Rocco Baldelli of the Minnesota Twins has narrowly beaten out Aaron Boone of the New York Yankees to win AL Manager of the Year.
Both received 13 first-place votes in balloting by the Baseball Writers’ Association of America revealed Tuesday night, but Baldelli got more second-place votes in his first year on the job. The 38-year-old is the youngest to win the award.
Baldelli took over a team that won 78 games in 2018 and pushed them to 101 victories and an AL Central title. He worked tightly with Minnesota’s analytics-focused front office - a shift from predecessor Paul Molitor, who won this award in 2017 - and oversaw a turnaround propelled by the team’s major league record 307 home runs.
The NL winner was set to be announced later Tuesday. The finalists are the Braves’ Brian Snitker, Brewers’ Craig Counsell and Cardinals’ Mike Shildt.
Follow Jake Seiner: https://twitter.com/Jake_Seiner
More AP MLB: https://apnews.com/MLB and https://twitter.com/AP_Sports
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.