| Package | Description |
|---|---|
| org.bitcoinj.core |
The core package contains classes for network messages like
Block and
Transaction , peer connectivity via PeerGroup ,
and block chain management. |
| org.bitcoinj.jni | |
| org.bitcoinj.protocols.channels |
Micropayment channels allow for rapid tiny payments to be made to a third party once a channel has been set up, using
some of the advanced features of the Bitcoin protocol.
|
| org.bitcoinj.script |
Classes for working with and executing Bitcoin script programs, as embedded in inputs and outputs.
|
| org.bitcoinj.signers |
Transaction signers know how to calculate signatures over transactions in different contexts, for example, using
local private keys or fetching them from remote servers.
|
| org.bitcoinj.wallet |
Classes that support the
Wallet , which knows how to find and save transactions relevant to
a set of keys or scripts, calculate balances, and spend money: the wallet has many features and can be extended
in various ways, please refer to the website for documentation on how to use it. |
| org.bitcoinj.wallet.listeners |
| Modifier and Type | Method and Description |
|---|---|
Script |
UTXO.getScript()
The Script object which you can use to get address, script bytes or script type.
|
Script |
TransactionOutput.getScriptPubKey() |
Script |
TransactionInput.getScriptSig()
Returns the script that is fed to the referenced output (scriptPubKey) script in order to satisfy it: usually
contains signatures and maybe keys, but can contain arbitrary data if the output script accepts it.
|
| Modifier and Type | Method and Description |
|---|---|
TransactionInput |
Transaction.addInput(Sha256Hash spendTxHash,
long outputIndex,
Script script)
Creates and adds an input to this transaction, with no checking that it's valid.
|
TransactionOutput |
Transaction.addOutput(Coin value,
Script script)
Creates an output that pays to the given script.
|
TransactionInput |
Transaction.addSignedInput(TransactionOutPoint prevOut,
Script scriptPubKey,
ECKey sigKey)
Same as
Transaction.addSignedInput(TransactionOutPoint, org.bitcoinj.script.Script, ECKey, org.bitcoinj.core.Transaction.SigHash, boolean)
but defaults to Transaction.SigHash.ALL and "false" for the anyoneCanPay flag. |
TransactionInput |
Transaction.addSignedInput(TransactionOutPoint prevOut,
Script scriptPubKey,
ECKey sigKey,
Transaction.SigHash sigHash,
boolean anyoneCanPay)
Adds a new and fully signed input for the given parameters.
|
TransactionSignature |
Transaction.calculateSignature(int inputIndex,
ECKey key,
Script redeemScript,
Transaction.SigHash hashType,
boolean anyoneCanPay)
Calculates a signature that is valid for being inserted into the input at the given position.
|
static Address |
Address.fromP2SHScript(NetworkParameters params,
Script scriptPubKey)
Returns an Address that represents the script hash extracted from the given scriptPubKey
|
Sha256Hash |
Transaction.hashForSignature(int inputIndex,
Script redeemScript,
Transaction.SigHash type,
boolean anyoneCanPay)
Calculates a signature hash, that is, a hash of a simplified form of the transaction.
|
boolean |
TransactionBag.isWatchedScript(Script script)
Returns true if this wallet is watching transactions for outputs with the script.
|
void |
TransactionInput.setScriptSig(Script scriptSig)
Set the given program as the scriptSig that is supposed to satisfy the connected output script.
|
| Constructor and Description |
|---|
UTXO(Sha256Hash hash,
long index,
Coin value,
int height,
boolean coinbase,
Script script)
Creates a stored transaction output.
|
UTXO(Sha256Hash hash,
long index,
Coin value,
int height,
boolean coinbase,
Script script,
String address)
Creates a stored transaction output.
|
| Modifier and Type | Method and Description |
|---|---|
void |
NativeScriptsChangeEventListener.onScriptsChanged(Wallet wallet,
List<Script> scripts,
boolean isAddingScripts) |
void |
NativeWalletEventListener.onScriptsChanged(Wallet wallet,
List<Script> scripts,
boolean isAddingScripts) |
| Modifier and Type | Method and Description |
|---|---|
protected Script |
PaymentChannelV1ServerState.createOutputScript() |
protected Script |
PaymentChannelV2ServerState.createOutputScript()
Creates a P2SH script outputting to the client and server pubkeys
|
protected abstract Script |
PaymentChannelServerState.createOutputScript() |
Script |
PaymentChannelServerState.getContractScript() |
protected Script |
PaymentChannelV2ClientState.getContractScript() |
protected abstract Script |
PaymentChannelClientState.getContractScript() |
protected Script |
PaymentChannelV1ClientState.getContractScript() |
protected Script |
PaymentChannelV1ServerState.getSignedScript() |
protected Script |
PaymentChannelV2ServerState.getSignedScript() |
protected abstract Script |
PaymentChannelServerState.getSignedScript()
Gets the script that signatures should sign against.
|
protected Script |
PaymentChannelV2ClientState.getSignedScript() |
protected abstract Script |
PaymentChannelClientState.getSignedScript()
Gets the script that is signed.
|
protected Script |
PaymentChannelV1ClientState.getSignedScript() |
| Modifier and Type | Method and Description |
|---|---|
Script |
ScriptBuilder.build()
Creates a new immutable Script based on the state of the builder.
|
static Script |
ScriptBuilder.createCLTVPaymentChannelInput(byte[] from,
byte[] to) |
static Script |
ScriptBuilder.createCLTVPaymentChannelInput(TransactionSignature from,
TransactionSignature to) |
static Script |
ScriptBuilder.createCLTVPaymentChannelOutput(BigInteger time,
ECKey from,
ECKey to) |
static Script |
ScriptBuilder.createCLTVPaymentChannelP2SHInput(byte[] from,
byte[] to,
Script redeemScript) |
static Script |
ScriptBuilder.createCLTVPaymentChannelP2SHRefund(TransactionSignature signature,
Script redeemScript) |
static Script |
ScriptBuilder.createCLTVPaymentChannelRefund(TransactionSignature signature) |
Script |
Script.createEmptyInputScript(ECKey key,
Script redeemScript)
Creates an incomplete scriptSig that, once filled with signatures, can redeem output containing this scriptPubKey.
|
static Script |
ScriptBuilder.createInputScript(TransactionSignature signature)
Creates a scriptSig that can redeem a pay-to-pubkey output.
|
static Script |
ScriptBuilder.createInputScript(TransactionSignature signature,
ECKey pubKey)
Creates a scriptSig that can redeem a pay-to-address output.
|
static Script |
ScriptBuilder.createMultiSigInputScript(List<TransactionSignature> signatures)
Create a program that satisfies an OP_CHECKMULTISIG program.
|
static Script |
ScriptBuilder.createMultiSigInputScript(TransactionSignature... signatures)
Create a program that satisfies an OP_CHECKMULTISIG program.
|
static Script |
ScriptBuilder.createMultiSigInputScriptBytes(List<byte[]> signatures)
Create a program that satisfies an OP_CHECKMULTISIG program, using pre-encoded signatures.
|
static Script |
ScriptBuilder.createMultiSigInputScriptBytes(List<byte[]> signatures,
byte[] multisigProgramBytes)
Create a program that satisfies an OP_CHECKMULTISIG program, using pre-encoded signatures.
|
static Script |
ScriptBuilder.createMultiSigOutputScript(int threshold,
List<ECKey> pubkeys)
Creates a program that requires at least N of the given keys to sign, using OP_CHECKMULTISIG.
|
static Script |
ScriptBuilder.createOpReturnScript(byte[] data)
Creates a script of the form OP_RETURN [data].
|
static Script |
ScriptBuilder.createOutputScript(Address to)
Creates a scriptPubKey that encodes payment to the given address.
|
static Script |
ScriptBuilder.createOutputScript(ECKey key)
Creates a scriptPubKey that encodes payment to the given raw public key.
|
static Script |
ScriptBuilder.createP2SHMultiSigInputScript(List<TransactionSignature> signatures,
Script multisigProgram)
Create a program that satisfies a pay-to-script hashed OP_CHECKMULTISIG program.
|
static Script |
ScriptBuilder.createP2SHOutputScript(byte[] hash)
Creates a scriptPubKey that sends to the given script hash.
|
static Script |
ScriptBuilder.createP2SHOutputScript(int threshold,
List<ECKey> pubkeys)
Creates a P2SH output script with given public keys and threshold.
|
static Script |
ScriptBuilder.createP2SHOutputScript(Script redeemScript)
Creates a scriptPubKey for the given redeem script.
|
static Script |
ScriptBuilder.createRedeemScript(int threshold,
List<ECKey> pubkeys)
Creates redeem script with given public keys and threshold.
|
Script |
Script.getScriptSigWithSignature(Script scriptSig,
byte[] sigBytes,
int index)
Returns a copy of the given scriptSig with the signature inserted in the given position.
|
static Script |
ScriptBuilder.updateScriptWithSignature(Script scriptSig,
byte[] signature,
int targetIndex,
int sigsPrefixCount,
int sigsSuffixCount)
Returns a copy of the given scriptSig with the signature inserted in the given position.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Script.correctlySpends(Transaction txContainingThis,
long scriptSigIndex,
Script scriptPubKey)
Deprecated.
Use
correctlySpends(org.bitcoinj.core.Transaction, long, org.bitcoinj.script.Script, java.util.Set)
instead so that verification flags do not change as new verification options
are added. |
void |
Script.correctlySpends(Transaction txContainingThis,
long scriptSigIndex,
Script scriptPubKey,
Set<Script.VerifyFlag> verifyFlags)
Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey.
|
static Script |
ScriptBuilder.createCLTVPaymentChannelP2SHInput(byte[] from,
byte[] to,
Script redeemScript) |
static Script |
ScriptBuilder.createCLTVPaymentChannelP2SHRefund(TransactionSignature signature,
Script redeemScript) |
Script |
Script.createEmptyInputScript(ECKey key,
Script redeemScript)
Creates an incomplete scriptSig that, once filled with signatures, can redeem output containing this scriptPubKey.
|
static Script |
ScriptBuilder.createP2SHMultiSigInputScript(List<TransactionSignature> signatures,
Script multisigProgram)
Create a program that satisfies a pay-to-script hashed OP_CHECKMULTISIG program.
|
static Script |
ScriptBuilder.createP2SHOutputScript(Script redeemScript)
Creates a scriptPubKey for the given redeem script.
|
static void |
Script.executeScript(Transaction txContainingThis,
long index,
Script script,
LinkedList<byte[]> stack,
boolean enforceNullDummy)
|
static void |
Script.executeScript(Transaction txContainingThis,
long index,
Script script,
LinkedList<byte[]> stack,
Set<Script.VerifyFlag> verifyFlags)
Exposes the script interpreter.
|
int |
Script.getNumberOfBytesRequiredToSpend(ECKey pubKey,
Script redeemScript)
Returns number of bytes required to spend this script.
|
Script |
Script.getScriptSigWithSignature(Script scriptSig,
byte[] sigBytes,
int index)
Returns a copy of the given scriptSig with the signature inserted in the given position.
|
static Script |
ScriptBuilder.updateScriptWithSignature(Script scriptSig,
byte[] signature,
int targetIndex,
int sigsPrefixCount,
int sigsSuffixCount)
Returns a copy of the given scriptSig with the signature inserted in the given position.
|
| Constructor and Description |
|---|
ScriptBuilder(Script template)
Creates a fresh ScriptBuilder with the given program as the starting point.
|
| Modifier and Type | Field and Description |
|---|---|
Map<Script,List<ChildNumber>> |
TransactionSigner.ProposedTransaction.keyPaths
HD key paths used for each input to derive a signing key.
|
| Modifier and Type | Field and Description |
|---|---|
Script |
RedeemData.redeemScript |
| Modifier and Type | Method and Description |
|---|---|
Script |
MarriedKeyChain.freshOutputScript(KeyChain.KeyPurpose purpose)
Create a new married key and return the matching output script
|
Script |
DeterministicKeyChain.freshOutputScript(KeyChain.KeyPurpose purpose)
Create a new key and return the matching output script.
|
| Modifier and Type | Method and Description |
|---|---|
List<Script> |
Wallet.getWatchedScripts()
Returns a snapshot of the watched scripts.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
Wallet.canSignFor(Script script)
Returns true if this wallet has at least one of the private keys needed to sign for this scriptPubKey.
|
boolean |
Wallet.isWatchedScript(Script script)
Returns true if this wallet is watching transactions for outputs with the script.
|
static RedeemData |
RedeemData.of(ECKey key,
Script program)
Creates RedeemData for pay-to-address or pay-to-pubkey input.
|
static RedeemData |
RedeemData.of(List<ECKey> keys,
Script redeemScript) |
| Modifier and Type | Method and Description |
|---|---|
int |
Wallet.addWatchedScripts(List<Script> scripts)
Adds the given output scripts to the wallet to be watched.
|
protected void |
Wallet.queueOnScriptsChanged(List<Script> scripts,
boolean isAddingScripts) |
boolean |
Wallet.removeWatchedScripts(List<Script> scripts)
Removes the given output scripts from the wallet that were being watched.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AbstractWalletEventListener.onScriptsChanged(Wallet wallet,
List<Script> scripts,
boolean isAddingScripts)
Deprecated.
|
void |
ScriptsChangeEventListener.onScriptsChanged(Wallet wallet,
List<Script> scripts,
boolean isAddingScripts)
Called whenever a new watched script is added to the wallet.
|
Copyright © 2022. All rights reserved.


-
Landing PageModern design with responsive mobile first technology
to increase conversion rate with huge amount of traffic.
User ExperienceSleek and Modern Design to enhance the user experience with simple and user friendly environment.
TechnologEverything is based on modern tools and framework (bootstrap) and best css libraries to optimize the final product.
GRAPHICPixel Perfect Graphics and images according to the screen ratio to minimize the loading time and maximize satisfaction.
-
PSDNeed Conversion!
No problem I am professional in designing and you will get the excat replica with clean code.
Custom WebsitePreferr Customize new and personal layout. No problem just provide the idea and we convert every word into life.
BugsFinal Product is always bugs free. Its all about clean and well commented and cross-browser compatible code.
Stock ImagesNo need to pay for every image.
i will provide stock images with one subscription. After all we care about you.


Class reference
| Class | Breakpoint | Properties |
|---|---|---|
| .container | None | width: 100%; |
| sm (640px) | max-width: 640px; | |
| md (768px) | max-width: 768px; | |
| lg (1024px) | max-width: 1024px; | |
| xl (1280px) | max-width: 1280px; |
Usage
The .container
class sets the max-width
of an element to match the min-width
of the current breakpoint. This is useful if you'd prefer to design for a fixed set of screen sizes instead of trying to accommodate a fully fluid viewport.
Note that unlike containers you might have used in other frameworks, Tailwind's container does not center itself automatically and does not have any built-in horizontal padding.
To center a container, use the .mx-auto
utility:

To add horizontal padding, use the .px-{size}
utilities:

If you'd like to center your containers by default or include default horizontal padding, see the customization options below.
Customizing
Centering by default
To center containers by default, set the center
option to true
in the theme.container
section of your config file:
// tailwind.config.js
module.exports = {
theme: {
container: {
center: true,
},
},
}
Horizontal padding
To add horizontal padding by default, specify the amount of padding you'd like using the padding
option in the theme.container
section of your config file:
// tailwind.config.js
module.exports = {
theme: {
container: {
padding: '2rem',
},
},
}
Disabling
If you don't plan to use the .container
class in your project, you can disable it entirely by setting the container
property to false
in the corePlugins
section of your config file:


If you are the team captain, you will need the names and emails of the 10 to 16 players that you plan on registering and 3 possible country names you would like your team to be called.
No worries! There is individual player registration for both the Co-Ed and Women's tournaments! That means that teams that are in need of more players will be calling on you to join them. You can find the registration form for individual registration in the same place as for teams. Check out the register tab.
In the Co-Ed tournament there is a max of 2 (PAST or PRESENT) club players allowed on a team roster. For the Women's tournament there is a max of 3 club players allowed.
For the Co-ed tournament each player pays $10 and for the Women's each player pays $5. Each team is asked to raise $100 for Gonzo Soccer as well. Check out Gonzo to learn more about the program we are donating to!
The Co-Ed tournament will be 40 teams divided into 10 groups. There will be group stages and then elimination bracket, just like FIFA World Cup. The Women's tournament will have 8 teams split into 2 groups.


AWS::GuardDuty::Detector
The AWS::GuardDuty::Detector
resource creates a single Amazon GuardDuty
detector. A detector is an object that represents the GuardDuty service. You must
create a
detector for GuardDuty to become operational.
Topics
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::GuardDuty::Detector", "Properties" : { "Enable" :
Boolean
, "FindingPublishingFrequency" :String
} }
YAML
Type: AWS::GuardDuty::Detector Properties: Enable:
Boolean
FindingPublishingFrequency:String
Properties
Enable
-
A Boolean value that specifies whether the detector is to be enabled.
Required: Yes
Type: Boolean
Update requires: No interruption
FindingPublishingFrequency
-
Specifies the frequency of notifications sent about the subsequent finding occurrences. Valid values include only the following: FIFTEEN_MINUTES, ONE_HOUR, SIX_HOURS.
Required: No
Type: String
Update requires: No interruption
Return Values
Ref
When you pass the logical ID of an AWS::GuardDuty::Detector
resource to the
intrinsic Ref
function, the function returns the unique ID of the created
detector.
For more information about using the Ref
function, see Ref.
Examples
Declaring a GuardDuty Detector Resource
The following example shows how to declare an AWS::GuardDuty::Detector
resource to create a GuardDuty detector.
JSON
"mydetector": { "Type": "AWS::GuardDuty::Detector", "Properties": { "Enable": true, "FindingPublishingFrequency": "FIFTEEN_MINUTES" } }
YAML
mydetector: Type: AWS::GuardDuty::Detector Properties: Enable: true FindingPublishingFrequency: FIFTEEN_MINUTES


Event Structure
Introduction
If you are searching for an event to unleash the puzzle busting instincts in you then you are at the right place. Here you dawn the light of Sherlock Holmes in you, with the help of illustrious aide Mr. Google and fire away the silver-bullets from the tricky guns.
Structure
- There Will be 2 phases
- First phase, which will be held on 25th February. The timing for the first phase is 7:30pm to 9:30pm.
- There will be 20 teams from DA-IICT to be selected and 20 from other colleges for the 2nd phase.
- The date for 2nd phase is 3rd March and 2nd phase will start at 2:00pm.
- There are 40 questions, and you are allowed to use google as much as you want.
- You have a total of 5 passes, which you can use to skip questions you can't find answer to.
- You cannot return to the skipped question.
- Each question gives you 10 points. The team with the highest points wins at the ending of the game period. If multiple teams finish with the same score, the team which finished earliest wins.
- The link to the game will be updated soon. Keep checking and stay tuned.
- Note:Team from DA-IICT will have to play the 2nd phase from the lab.
Rules
- Max. team size is 2.
- Each participant should register only once specifying their teamates..
- Always answer your question with no spaces(if any) in between words. Don't use punctuations.
(i.e. if the answer is “googlock holmes ” write “googlockholmes”)
- Always answer your question in lower case letters.
- Once you skip a questions you can't return to that later.
- For each correct answer your score increases by 10 or by corresponding number if mentioned explicitly.
- Questions which attract negative marks will be mentioned explicitly.
- Any sort of malpractice like multiple accounts shall result in disqualification and coordinators decision shall be deemed final.
- Teams can login in to the specified webpage any time during the event.
- In case of any disputes the decision of the Team GooglockHolmes would be final.
Schedule :
FIRST PHASE ON 25TH FEB FROM 7:30pm to 9:30pm.
SECOND PHASE ON 3RD MARCH FROM 2pm onwards.
Developers: Shantanu Jain | Harsh Nisar | Mayank Hinger | Zubin Kapadia


Home
Connect
registration
What is your name?

What languages are you fluent ?
English
French
Spanish
Italian
German
Hebrew
Swahili
Chinese
Portuguese
Japanese
What language do you want to learn?
English
French
Spanish
Italian
German
Hebrew
Swahili
Chinese
Portuguese
Japanese


I am a web-developer with experience building front-end and back-end services. I was an educator for 12 years and learned to code through self-directed learning and through attending Eleven Fifty Academy located in Carmel, IN. I have adapted skills learned during my years as an educator to enhance the products I deliver.
To build software, I utilize the MEAN Stack, jQuery, Bootstrap, HTML5 and CSS3
I follow a process that allows me to optimize your front-end design so your web presence is effective! My back-end design allows the web site to run efficiently so your needs and your customers' needs are always met! Email me so we can get started building your web presence!
The following items are projects used to learn and hone new skills. Each project displays my growth as a web developer. Through my learning, I have developed skills in the MEAN Stack, jQuery, HTML, and CSS. I have also improved my skills in deployment by deploying web apps on heroku and cloud foundry.
Click the images to see each project.


muspy.core¶
Functions for MusPy objects.
This module defines functions that can be applied to a MusPy object.
Functions¶
adjust_resolution
adjust_time
append
clip
get_end_time
get_real_end_time
remove_duplicate
sort
to_ordered_dict
transpos
-
muspy.core.
adjust_resolution
(music, target=None, factor=None)[source]¶ Adjust resolution and update the timing of time-stamped objects.
- Parameters
music (
muspy.Music
object) – MusPy music object to adjust.target (int, optional) – Target resolution.
factor (int or float, optional) – Factor used to adjust the resolution based on the formula: new_resolution = old_resolution * factor. For example, a factor of 2 double the resolution, and a factor of 0.5 halve the resolution.
-
muspy.core.
adjust_time
(obj, func)[source]¶ Adjust the timing of time-stamped objects.
- Parameters
obj (
muspy.Music
ormuspy.Track
object) – Object to adjust.func (callable) – The function used to compute the new timing from the old timing, i.e., new_time = func(old_time).
See also
muspy.adjust_resolution()
Adjust the resolution and the timing of time-stamped objects.
Note
The resolution are left unchanged.
-
muspy.core.
append
(obj1, obj2)[source]¶ Append an object to the correseponding list.
If obj1 is of type
muspy.Music
, obj2 can bemuspy.KeySignature
,muspy.TimeSignature
,muspy.Lyric
,muspy.Annotation
ormuspy.Track
.If obj1 is of type
muspy.Track
, obj2 can bemuspy.Note
,muspy.Lyric
ormuspy.Annotation
.If obj1 is of type
muspy.Timing
, obj2 can bemuspy.Tempo
.
- Parameters
obj1 (
muspy.Music
,muspy.Track
or) –muspy.Tempo
object Object to which obj2 to append.obj2 (MusPy objects (see below)) – Object to be appended to obj1.
-
muspy.core.
clip
(obj, lower=0, upper=127)[source]¶ Clip the velocity of each note.
- Parameters
obj (
muspy.Music
,muspy.Track
ormuspy.Note
) – object Object to clipp.lower (int or float, optional) – Lower bound. Defaults to 0.
upper (int or float, optional) – Upper bound. Defaults to 127.
-
muspy.core.
get_end_time
(obj, is_sorted=False)[source]¶ Return the end time, i.e., the time of the last event in all tracks.
- This includes tempos, key signatures, time signatures, notes offsets,
lyrics and annotations.
- Parameters
obj (
muspy.Music
ormuspy.Track
object) – Object to inspect.is_sorted (bool) – Whether all the list attributes are sorted. Defaults to False.
-
muspy.core.
get_real_end_time
(music, is_sorted=False)[source]¶ Return the end time in realtime.
- This includes tempos, key signatures, time signatures, notes offsets,
lyrics and annotations. Assume 120 qpm (quarter notes per minute) if no tempo information is available.
- Parameters
music (
muspy.Music
object) – Object to inspect.is_sorted (bool) – Whether all the list attributes are sorted. Defaults to False.
-
muspy.core.
remove_duplicate
(obj)[source]¶ Remove duplicate change events.
- Parameters
obj (
muspy.Music
object) – Object to process.
-
muspy.core.
sort
(obj)[source]¶ Sort all the time-stamped objects with respect to event time.
If a
muspy.Music
is given, this will sort key signatures, time signatures, lyrics and annotations, along with notes, lyrics and annotations for each track.If a
muspy.Track
is given, this will sort notes, lyrics and annotations.
- Parameters
obj (
muspy.ComplexBase
object) – Object to sort.
-
muspy.core.
to_ordered_dict
(obj, ignore_null=True)[source]¶ Return an OrderedDict converted from a Music object.
- Parameters
obj (
muspy.Base
object) – MusPy object to convert.- Returns
Converted OrderedDict.
- Return type
OrderedDict
-
muspy.core.
transpose
(obj, semitone)[source]¶ Transpose all the notes by a number of semitones.
- Parameters
obj (
muspy.Music
,muspy.Track
ormuspy.Note
) –object – Object to transpose.
semitone (int) – The number of semitones to transpose the notes. A positive value raises the pitches, while a negative value lowers the pitches.


You Comment On Your Player Of The Month
by Soccer LadumaThe month of November was a brilliant month of football which saw two Soweto derbies over 7 days.
Filled with goals, controversy, and intensity, the Telkom Knockout served us with a couple of surprises, while the South African U23 side booked their place in next year’s Olympic Games in Japan.
For a summary of all the games, check out this week’s You Choose The Team of the Month, and then let us know what you thought of the top player or players for this month.
Please leave your comments on this month’s top performers in the comments section below. The best comments may feature in Wednesday’s Soccer Laduma newspaper.


"Don’t sleep, don’t eat, just play – repeat!"
"Wherever is a hole, we have you covered!"

"We know all your nasty dreams!"
"In a corner next to you!"
"The first treat on the market for you and your best friend!"
 Hello hot summer body!"


DDoS protection is activated for your IP %sPlease click bellow to pass protection, Or you will be automatically redirected to the requested page after %d seconds. To continue working with web-site, please make sure that you have enabled JavaScript. |
|
DDoS protection by timIT-DPUPR |


Virtual Classroom
Search
Rkcl
Getting started
Home page
About
Download
Quick start
Full tutorial
Toggle side navigation
Home
Getting started
Tutorial
Products
Contact us
Tools
Support
Editor & Snippets
Articles
JavaScript News
Web Design News
My profile
Settings
Affiliate account
Orders
Log Out
Settings
×
×
Profile info
Save changes
Account settings
Save changes
Password change
Reset password


Loop Waveform Visualizer
Mouse to tilt. Mousewheel to zoom. Music by
Beytah
. Built by
@felixturner
using Web Audio API and
Three.js
.


| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here are some tools that you might find useful while developing code.
Tags are an index to the functions and global variables declared in a
program. Many editors, including Emacs and vi
, can use
them. The Makefile
in pintos/src
produces Emacs-style
tags with the command make TAGS
or vi
-style tags with
make tags
.
In Emacs, use M-. to follow a tag in the current window, C-x 4 . in a new window, or C-x 5 . in a new frame. If your cursor is on a symbol name for any of those commands, it becomes the default target. If a tag name has multiple definitions, M-0 M-. jumps to the next one. To jump back to where you were before you followed the last tag, use M-*.
The cscope
program also provides an index to functions and
variables declared in a program. It has some features that tag
facilities lack. Most notably, it can find all the points in a
program at which a given function is called.
The Makefile
in pintos/src
produces cscope
indexes when it is invoked as make cscope
. Once the index has
been generated, run cscope
from a shell command line; no
command-line arguments are normally necessary. Then use the arrow
keys to choose one of the search criteria listed near the bottom of
the terminal, type in an identifier, and hit Enter.
cscope
will then display the matches in the upper part of
the terminal. You may use the arrow keys to choose a particular
match; if you then hit Enter, cscope
will invoke the
default system editor(10) and position the
cursor on that match. To start a new search, type Tab. To exit
cscope
, type Ctrl-d.
Emacs and some versions of vi
have their own interfaces to
cscope
. For information on how to use these interface,
visit http://cscope.sourceforge.net, the cscope
home
page.
It's crucial that you use a source code control system to manage your Pintos code. This will allow you to keep track of your changes and coordinate changes made by different people in the project. For this class we recommend that you use Git; if you followed the instructions on getting started, a Git repository will already have been created for you. If you don't already know how to use Git, we recommend that you read the Pro Git book online.
VNC stands for Virtual Network Computing. It is, in essence, a remote display system which allows you to view a computing "desktop" environment not only on the machine where it is running, but from anywhere on the Internet and from a wide variety of machine architectures. It is already installed on the lab machines. For more information, look at the VNC Home Page.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |


Origin Article: 3 Powerful Paulo Coelho Quotes You Must Understand to Make Your Dreams Come True
Paulo Coelho Quotes from The Alchemist are Life-Changing.
Paulo Coelho Quotes or his books, all of them talk about following your dreams, understanding your soul's desire and finding your connection with the Universe. And I believe this is what distinguishes him from all other writers.
Most of you have read The Alchemist if you haven't you should. If at all you haven't read this book but you must have read the most famous quote from this masterpiece again and again.
I called it the most powerful Paulo Coelho Quote ever.
You must have heard it many times before right. But in spite of knowing this most of the time, you struggle to believe in it or find it difficult to believe that the Universe is working this way for you. Isn't it?
Yes, this is at the top among the Paulo Coelho Quotes from The Alchemist. But the truth is if you want to understand the Universal way of working you can't understand everything through this one quote only.
You must read the three most important Paulo Coelho Quotes from The Alchemist and find the connection within to understand when the Universe conspires for your dreams.
So let's read the Top Three Motivational Paulo Coelho Quotes From The Alchemist.
Three Most Powerful Paulo Coelho Quotes
You must have read all these three quotes and probably fallen in love with the third one “when you want something, all the universe conspires in helping you to achieve it.”
But in spite of knowing this quote and desiring many things you still couldn't get what you want. What is the reason the Universe doesn't conspire for you to achieve your dreams?
The secret to this most famous quote stored in the other two quotes.
The first quote says “your desire originates in the soul of the Universe” and that's why the Universe conspires in helping you achieve it. So when the Universe conspires for your dreams, it works for making the desire within the soul of the Universe come true.
It means your desire and the desire of the Soul of The Universe is the same.
But why the universe couldn't make the desire come true when it originates in its soul, and it supposed to get manifested through you.
Read the second quote “The soul of the Universe nourished by people's happiness.”
So if you desire something with happiness and if you find joy working on that dream, then you nourished the soul of the Universe. When you nourished the soul of the Universe for that particular desire, the whole universe conspires in helping you to achieve it.
If any of your dreams are not coming true whether it is about love, relationship, job, money, health or simply well-being, the reason is this only. You are not nourishing the soul of the Universe with your happiness.
No matter how badly you want something but if you want it with desperation, if you want it because you feel sad without it then you won't get it. If you want something with the feelings of anger or sadness or frustration, then the Universe can't make it true for you. Because with all these negative feelings, you are weakening the soul of the Universe and making the desire die within it.
I believe now you have clearly understood these three powerful Paulo Coelho Quotes, and it's secret. If you keep these three quotes in your mind and work on your dreams, happily the Universe will conspire in making you achieve it.
Honestly, it is not possible for everyone to feel happy about their dreams all the time. There may be moments of sadness or challenges. But knowing the secret of the Universe makes you aware that what you are doing wrong.
Feeling sad or negative from time to time is normal. We are human, and the greatest gift of being human is that we have a mind to choose the right thoughts and actions. We have the gift of consciousness to change our focus from negativity to positivity and from sadness to happiness.
When you remember this secret of the Universe and use your gift of consciousness, you will manifest everything you want.
As Albert Schweitzer has said:
I want you to remember these 3 powerful Paulo Coelho Quotes from The Alchemist. These three quotes and their relationship will remind you to live with HAPPINESS for making your dreams come true.


Exodus 36:22
One board had two tenons, equally distant one from another: thus did he make for all the boards of the tabernacle.


|
Herbrand Equivalence
LLVM implementation of Herbrand Equivalence algorithm mentioned at https://arxiv.org/abs/1708.04976
|
Data Structures | |
| struct | CfgNodeTy |
| struct | HerbrandPass |
| Body of the pass. More... | |
Typedefs | |
| typedef std::tuple< char, Value *, Value * > | ExpressionTy |
| Represents an expression of length at most two. More... | |
Functions | |
| std::set< char > | Ops ({'+'}) |
| Set of operators used in the program. More... | |
| void | assignNames (Function &F) |
| Assigns names to basic blocks and variables for easy reference. More... | |
| void | assignIndex (Function &F) |
Maps expressions of length atmost two to integers arbitrarily for indexing purpose by updating IndexExp map. Also Initialises Constants and Variables by looking through the instructions in the program. More... | |
| void | createCFG (Function &F) |
| Creates control flow graph corresponding to the program. More... | |
| void | printValue (Value const *value) |
| Prints a constant/variable in readable form. More... | |
| void | printExpression (ExpressionTy const &exp) |
| Prints an expression in readable form. More... | |
| void | printCode (Function &F) |
| Prints the llvm source code. More... | |
| void | printCFG () |
| Prints the control flow graph corresponding to the program. More... | |
| void | printPartition (std::vector< int > const &partition) |
| Prints a partition in readable format. More... | |
| bool | samePartition (std::vector< int > const &first, std::vector< int > const &second) |
| Checks whether two partitions are same. More... | |
| int | findSet (std::vector< int > const &partition, ExpressionTy const &exp) |
| Returns set identifier for a given two length expression at a program point. More... | |
| void | findInitialPartition (std::vector< int > &partition) |
| Finds initial partition. More... | |
| void | getClass (std::vector< int > const &partition, int expIdx, std::set< int > &expClass) |
| Returns equivalence class of an expression at a given program point. More... | |
| void | transferFunction (int cfgIndex) |
| Transfer function associated with Herbrand analysis. More... | |
| void | confluenceFunction (int cfgIndex) |
| Confluence function associated with Herbrand analysis. More... | |
| void | HerbrandAnalysis (Function &F) |
| Main Herbrand analysis function. More... | |
Variables | |
| std::set< Value * > | Constants |
| Set of constants used in the program. More... | |
| std::set< Value * > | Variables |
| Set of variables used in the program. More... | |
| std::map< ExpressionTy, int > | IndexExp |
| Maps expressions to integer indexes. This indexing is arbitrarily fixed in the beginning and used throughout wherever indexing is required for the expressions. More... | |
| int | SetCnt = 0 |
| Counter to keep track of set identifiers. New set identifiers are created by incrementing this counter. More... | |
| std::vector< std::vector< int > > | Partitions |
| Vector to keep track of equivalence classes at each program point. More... | |
| std::map< std::tuple< char, int, int >, int > | Parent |
| Map to hold parent set identifiers. More... | |
| std::vector< CfgNodeTy > | CFG |
| Control flow graph corresponding to the program. More... | |
| std::map< Instruction *, int > | CfgIndex |
Stores CFG index for each instruction. More... | |
| typedef std::tuple<char, Value *, Value *> HerbrandPass::ExpressionTy |
Represents an expression of length at most two.
For two length expressions x op y
the tuple holds {op, x, y}
whereas for a constant or variable x
it holds `{'\0', x, nullptr}` (here the first and last element of the tuple have default value for consistency).
Definition at line 125 of file HerbrandEquivalence.cpp.
| void HerbrandPass::assignIndex | ( | Function & | F | ) |
Maps expressions of length atmost two to integers arbitrarily for indexing purpose by updating IndexExp
map. Also Initialises Constants
and Variables
by looking through the instructions in the program.
| [in] | F | Function block over which we are operating |
Definition at line 303 of file HerbrandEquivalence.cpp.
| void HerbrandPass::assignNames | ( | Function & | F | ) |
Assigns names to basic blocks and variables for easy reference.
| [in] | F | Function block over which we are operating |
Definition at line 275 of file HerbrandEquivalence.cpp.
| void HerbrandPass::confluenceFunction | ( | int | cfgIndex | ) |
Confluence function associated with Herbrand analysis.
| [in] | cfgIndex | Control flow graph node index on which confluence function is applied. |
Definition at line 869 of file HerbrandEquivalence.cpp.
| void HerbrandPass::createCFG | ( | Function & | F | ) |
Creates control flow graph corresponding to the program.
Definition at line 354 of file HerbrandEquivalence.cpp.
| void HerbrandPass::findInitialPartition | ( | std::vector< int > & | partition | ) |
Finds initial partition.
Finds a vector representing initial partition in which all expressions are in different partition (has non-equivalent set identifiers). It also updates Parent
map for set identifiers assigned to length two expressions.
| [out] | partition | Vector to store the initial partition. |
Definition at line 740 of file HerbrandEquivalence.cpp.
| int HerbrandPass::findSet | ( | std::vector< int > const & | partition, |
| ExpressionTy const & | exp | ||
| ) |
Returns set identifier for a given two length expression at a program point.
With the help of Parent
map, first a check is made if a set identifier representing the expression at the current program point exists. If so it is returned else a new set identifier is created by updating SetCnt
and returned. This information is also stored in the Parent
map for future use.
| [in] | partition | Vector representing the partition at the program point. |
| [in] | exp | Expression whose set identifier is required at the program point. |
Definition at line 704 of file HerbrandEquivalence.cpp.
| void HerbrandPass::getClass | ( | std::vector< int > const & | partition, |
| int | expIdx, | ||
| std::set< int > & | expClass | ||
| ) |
Returns equivalence class of an expression at a given program point.
The equivalence class is the set of indexes corresponding to expressions (as given by IndexExp
) which have same set identifiers as the index representing the expression (passed as parameter) in the partition at the program point.
| [in] | partition | Vector representing the partition at current program point. |
| [in] | expIdx | Index of expression whose equivalence class is required. |
| [out] | expClass | Set containing identifiers corresponding to the required equivalence class. |
Definition at line 773 of file HerbrandEquivalence.cpp.
| void HerbrandPass::HerbrandAnalysis | ( | Function & | F | ) |
Main Herbrand analysis function.
Definition at line 956 of file HerbrandEquivalence.cpp.
| std::set<char> HerbrandPass::Ops | ( | {'+'} | ) |
Set of operators used in the program.
| void HerbrandPass::printCFG | ( | ) |
Prints the control flow graph corresponding to the program.
Definition at line 565 of file HerbrandEquivalence.cpp.
| void HerbrandPass::printCode | ( | Function & | F | ) |
Prints the llvm source code.
| [in] | F | Function that has to be printed |
Definition at line 536 of file HerbrandEquivalence.cpp.
| void HerbrandPass::printExpression | ( | ExpressionTy const & | exp | ) |
Prints an expression in readable form.
| [in] | exp | Expression to be printed |
Definition at line 518 of file HerbrandEquivalence.cpp.
| void HerbrandPass::printPartition | ( | std::vector< int > const & | partition | ) |
Prints a partition in readable format.
| [in] | partition | The partition vector to be printed. |
Definition at line 615 of file HerbrandEquivalence.cpp.
| void HerbrandPass::printValue | ( | Value const * | value | ) |
Prints a constant/variable in readable form.
| [in] | value | LLVM representation of constant/variable |
Definition at line 502 of file HerbrandEquivalence.cpp.
| bool HerbrandPass::samePartition | ( | std::vector< int > const & | first, |
| std::vector< int > const & | second | ||
| ) |
Checks whether two partitions are same.
Two partitions are same if in the vectors representing them values at two indexes are equal in the first vector iff they are equal in the second vector.
| [in] | first | First partition |
| [in] | second | Second partition |
Definition at line 659 of file HerbrandEquivalence.cpp.
| void HerbrandPass::transferFunction | ( | int | cfgIndex | ) |
Transfer function associated with Herbrand analysis.
| [in] | cfgIndex | Control flow graph node index on which transfer function is applied. The function modifies Partitions[cfgIndex] . |
Definition at line 795 of file HerbrandEquivalence.cpp.
| std::vector<CfgNodeTy> HerbrandPass::CFG |
Control flow graph corresponding to the program.
It contains nodes only corresponding to reachable instructions and confluence points along with two special START and END nodes.
Definition at line 253 of file HerbrandEquivalence.cpp.
| std::map<Instruction *, int> HerbrandPass::CfgIndex |
Stores CFG
index for each instruction.
Definition at line 260 of file HerbrandEquivalence.cpp.
| std::set<Value *> HerbrandPass::Constants |
Set of constants used in the program.
Definition at line 85 of file HerbrandEquivalence.cpp.
| std::map<ExpressionTy, int> HerbrandPass::IndexExp |
Maps expressions to integer indexes. This indexing is arbitrarily fixed in the beginning and used throughout wherever indexing is required for the expressions.
Definition at line 135 of file HerbrandEquivalence.cpp.
| std::map<std::tuple<char, int, int>, int> HerbrandPass::Parent |
Map to hold parent set identifiers.
a1 =~ a2 and b1 =~ b2 at a program point iff (a1 + b1) =~ (a2 + b2). Parent map helps us to resolve this by storing set identifiers of compound expression (a1 + b1) as parent of set identifiers of its smaller sub-expressions (a1 and b1). Now, later when a new expression is formed by combining expressions (a2 and b2) with same set identifiers as those of the two sub-expressions (a1 and b1), we assign it (a2 + b2) the same identifier as the previous compound expression (a1 + b1). This map also helps to resolve other complex cases where some equivalence classes are lost in the middle of the program but appears later.
Definition at line 197 of file HerbrandEquivalence.cpp.
| std::vector<std::vector<int> > HerbrandPass::Partitions |
Vector to keep track of equivalence classes at each program point.
There is an entry for each program point in this vector which itself is a vector containing an entry for each expression of length atmost two. The entries for the expressions contains integer set identifiers. For a given program point two expressions are equivalent iff they have the same set identifier.
Partitions
vector are non-negative. But, if the partition represents TOP partition, the entries for all the expressions are -1. And the entry for any expression being -1 is sufficient to conclude that the partition vector represents TOP partition.Definition at line 169 of file HerbrandEquivalence.cpp.
| int HerbrandPass::SetCnt = 0 |
Counter to keep track of set identifiers. New set identifiers are created by incrementing this counter.
Definition at line 144 of file HerbrandEquivalence.cpp.
| std::set<Value *> HerbrandPass::Variables |
Set of variables used in the program.
Definition at line 96 of file HerbrandEquivalence.cpp.


Save a lot of work with CSS! In our CSS tutorial you will learn how to use CSS to control the style and layout of multiple Web pages all at once.
Start learning CSS!Learn by 70 examples! With our editor, you can edit CSS, and click on a test button to view the result.
Start learning CSS!At W3Schools you will find a complete CSS2 reference, listing properties, units of measurements, colors, and more.
Start learning CSS!Test your CSS skills at W3Schools!
Start learning CSS!


Hello and welcome to
{learn:Query}
Please read the README.md for instructions
Assigment 0
Example
Assigment 1
Simple Selector function
Assigment 2
CSS manipulation
Assigment 3
CSS class manipulation
Assigment 4
DOM manipulation
Assigment 5
Ajax request function
Assigment 6
Event Listeners
Assigment 7
Make learnQuery!


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 224796Geographiclocality/76764RiodeJaneiroBR.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/224796-Geographic-locality/topic/Rio.20de.20Janeiro.2C.20BR.html


Bootstrap provides directives to create dropdown menus such as the example above. Set dropdownToggle
on the
button or other element which toggles the dropdown, and dropdownMenu
on the menu contents. These should be
wrapped in a container with the dropdown
directive.
UX Aspects provides additional styles to create menus with common features including gutter icons, keyboard shortcut hints, and submenus.
To style menu items as above, apply the dropdown-menu-item
class to the a
element of the menu item.
This will contain up to three span
elements with classes as follows:
dropdown-menu-icon
- This contains the icon, which may be one of the UX Aspects Iconsor an image. If no icon is required, leave this empty to ensure a consistent gutter for other items with icons.dropdown-menu-text
- This contains the menu text.dropdown-menu-right
- Optionally, this may contain right aligned text or icons. dropdown-menu-hint
provides a default text style for keyboard shortcut hints here.See Keyboard Service for information on binding keyboard shortcuts.
Set the width on the ul
element to ensure that the menu contents will fit.
To create a menu item which opens a submenu, set the dropdown-submenu
class on the li
element,
and insert the menu contents below the a
element. The above example demonstrates both a standard and a custom submenu.
There are several directives which can be used within dropdowns to provide keyboard accessibility. The uxMenuNavigationToggle
directive
should be placed on the button that launches the dropdown. The uxMenuNavigation
directive should be placed on the dropdown menu element
and the uxMenuNavigationItem
directive should be placed on every item in the dropdown.
The following inputs and outputs are available on the menu navigation directives:
The following code can be used to create the example above:


Sections of the GTdef model
(Clicking on section heads will return to the Table of Contents)
-
Manual developed by Derrick Murekezi and Andrew Newman
GTdef is an implementation of the Okada (1985) dislocation model written by
Lujia Feng, Ting Chen, and Andrew Newman, with codes translated from disl (by Peter Cervelli). Okada (1985) can describe the
surface deformation associated with rectangular dislocations of most orientations, within
a purely-elastic half-space, however we've further adapted the codes to allow for horizontally layered materials.
Fault planes do require one edge to be horizontal. Dislocations can be described with dip-slip, strike-slip, and/or opening,
and hence can be used to describe a range of processes including earthquake faulting, interseismic
coupling, and planar fluid changes like magmatic dike inflation or groundwater withdrawal.
The code is developed so that one could perform both forward models that predict ground deformation
and inverse models that use data with errors and some modeling constraints to predict information about the
source. The source in either case can be either simple rectangular slips along the plane, orthogonal to it
or some combination of both.
Requirements:
- Algorithms are written in Matlab and require the 'Parameter estimation' toolbox for inversions.
- If you wish to use parallel processors, your version needs to include parpool, which was implemented around 2015.
- For plotting GMT version 5 or 6.
- These additional toolboxes and software are needed for Quadtree/InSAR processing:
- Image Processing Toolbox
- Parallel Processing Toolbox (if you want faster computation using multicore processing)
- Mapping Toolbox
- Signal Processing Toolbox
- grdwrite2.m from kylebrill @ GitHub
-
Set up Instructions:
- In the selected directory, to clone GTdef run
#this will create a copy of the code which you can pull to every time there is an update to the master git repository
git clone https://github.com/avnewman/GTDef.git
- Be sure the current version of the programs are in your path. You can check this using the path function, and add it using addpath.
# within matlab
> addpath('/path/to/GTdef/v4.0/stable/') %replacing with your actual path
- Additionally, create a separate directory to run examples and save files. Running Matlab calls in this directory will save your results in one place to be analysed later.
-
Kinematic Modeling:
A very brief discussion of kinematic modeling methods used here should exist. This would include each Okada (1985) analytical models,
the Wang et al (2003) layered method, and general injestion of Green's functions from other sources.
Inverse Modeling:
GTdef performs a bounded linear least-squares inversion of Green's functions to define
the best-fitting set of models to describe a dataset with errors. The program uses the parameter optimization toolbox program called lsqlin (Matlab info on it).
You can read more about it and general inversion methods from a number of books (including
Santamarina & Fratta, "Discrete Signals and Inverse Problems" [2005], and Menke, "Geophysical Data Analysis" -- particularly chapters 3 & 4).
While the simplified forward problem exists:
(1)
d = Gm
where Okada (1985) describes the Green's function, G, that relates model parameters m, to the data, d.
If data are numerous, and/or model parameters are greater than one, each can be written as a vector of size n and m, with the G being a matrix sized n x m.
The inversion equation, where we try to solve for model parameters becomes:
(2)
Gm = d
For a least-squares solution, the simplified inversion becomes:
(3)
mest = [GTG]-1GT d
Because we expect there to be interdependence between adjacent model patches, we can describe an additional set of equations to apply to the inversion and regularize the final model.
Every model patch mi can describe its model roughness as the Laplacian of that component of slip (e.g. ds, ss, ts). We will try to minimize that roughness for each slip component of the model, s, which here will be the same as m:
(4)
dp= 0 = κ∇2s
where κ is the smoothing kernel.
Furthermore, we combine the data weights and errors into a weighting matrix W.
Now, incorporating the errors and weighting, the forward problem becomes:
(5)
d = Gm =
=
m
where the data and greens function matrix are now everything in their respective matrices above.
The diagonal components of the weighting matrix Wii = (wi)0.5/ei,
which are the per datum weighting wi and errors ei.
With d and G now containing the smoothing and weighting terms, our model estimate can now be defined as:
(6)
mest = [GTG+ ε2I]-1GTd
where .
We can simplify this by defining the Generalized Inverse Matrix:
(7)
G-g = [GTG+ ε2I]-1GT
so:
(8)
mest = G-gd
The above mathematical formulation is modified for the bounded conditions used for the parameter estimation in lsqlin,
including the option of positivity constraints, which make the full formulation much more complicated.
However, the grouping of terms are important particularly for the development of distributed slip models as input into the solver,
and for understanding the model resolution matrix and ultimately resolution spread (an estimate of parameter importance).
-
We'll start with the most straight-forward case of a single vertical fault plane with strike-slip motion on the interface.
Example Forward Model Run:
The simplist model includes just one fault and one data-point ran in a forward sense to prediction deformation at that data-point. We will not stray significantly from there.
Input:
- We will create a vertical planar fault approximately 20 km long, with 1 meter, strike-slip motion, buried between 5 and 15 km depth. The output will describe the spatial deformation every 2 km across a 60x60 km grid surrounding the fault.
- To keep the algorithm from attempting an inversion, it is important that all slip parameter ranges for a given slip-type on a fault block have equal value (i.e. ss0=ssX, ds0=dsX, and ts0=tsX in this example).
- If all range values are set to zero '0', the initial value will be used. Here, we will have 1m of left-lateral (+) strike-slip that will not vary (all range parameters are set to zero).
- Input files should all end in .in
- The input file can be created in your favorite text-editor (e.g. vim). For simplicity here, we'll just direct stdout from an echo-command into a file called local1.in. The % represents a shell prompt.
% echo "
coord local # otherwise it will expect geographic coordinates
#fault type name lon1 lat1 lon2 lat2 z1 z2 dip ss ds ts ss0 ssX ds0 dsX ts0 tsX Nd Ns
fault 2 myfault 0 -10e3 0 10e3 5e3 15e3 90 1 0 0 0 0 0 0 0 0 1 1
#grid name Erot Nrot lon1(x1) lat1(y1) lon2(x2) lat2(y2) Ne Nn
grid 1kmx1km 0 0 -30e3 -30e3 30e3 30e3 31 31
" > local1.in
Run:
- To run GTdef, you must call up matlab (interactive and gui are not necessary).
- The processing code that oversees both forward and inverse models is GTdef and is called with just the input file name, and optionally, the number of processors you'd like it to use on your machine. By default, it will use all available processors if not defined.
# within matlab
> GTdef('local1.in',1) % will run on '1' core.
Output:
- This will create an output file called 'local1_fwd.out' that will repeat the model, and give predicted results for the defined grid locations (now as 'point' data-type).
Plotting results:
- Quick and dirty visualization can easily be achieved using the freely available gnuplot program. This allows us to look at the full 3D vector field.
# first comment out all lines that are not output data using vim or similar. (not shown)
% gnuplot
gnuplot> set ticslevel 0.0 # removes empty whitespace below plot
gnuplot> splot 'local1_fwd.out' u 4:5:(0):($7*1e5):($8*1e5):($9*1e5) w vect t "surface displacement" # just the surface results amplified to see variability
#If you're more adventurous, you can plot the fault too (this assumes the fault is vertically dipping).
gnuplot> splot "< awk '$1==\"point\"{print $0}' local1_fwd.out" u 4:5:(0):($7*1e5):($8*1e5):($9*1e5) w vect t "surface displacement",\
"< awk '$1==\"fault\"{printf \"%f %f %f\\n%f %f %f\\n%f %f %f\\n%f %f %f\\n%f %f %f\\n\", $4,$5,-$8,$6,$7,-$8,$6,$7,-$9,$4,$5,-$9,$4,$5,-$8}' local1_fwd.out" w l lw 2 lt -1 t "fault"
# use the cursor to move around the data
-
(from 'examples/Uniformslip/Solomon')
Input:
We will need to build the model, including gathering the appropriate data and then estabishing an appropriate a priori interface. In this example, we will use the very small tsunami earthquake described in Newman et al. (2011).
- Data: Here, we pull coastal subsidence data from sheet 3 of the
excel spreadsheet.
The data, being just vertical uplift/subsidence data need to be convert into the 'point 1' format in GTdef.
Errors are estimated to be approximately 0.1 m on all data (assuming error in tidal correction and prior high-tide estimates),
Because all data were measured using the same methods and likely have similar error values, we choose to give them all equal weight.
#point type name lon lat z Uv eUv weight
point 1 Rendova-Rendova_Harbor 157.33602 -8.40359 0.0 -0.15 0.10 1.0
point 1 Rendova-Epata_Creek 157.30622 -8.43730 0.0 0 0.10 1.0
point 1 Rendova-Mbaniata 157.26260 -8.63325 0.0 -0.70 0.10 1.0
point 1 Rendova-Hofofo_Pt 157.19633 -8.56530 0.0 0 0.10 1.0
point 1 Rendova-Habila 157.22920 -8.60414 0.0 -0.60 0.10 1.0
point 1 Rendova-Rava_Pt 157.40336 -8.72264 0.0 -0.60 0.10 1.0
point 1 Tetepare-Tofa 157.53432 -8.75576 0.0 -0.40 0.10 1.0
point 1 Tetepare-Jetty_near_Ecolodge 157.44286 -8.72234 0.0 -0.25 0.10 1.0
point 1 Tetepare-Ecolodge_boat_ramp 157.44321 -8.72120 0.0 -0.30 0.10 1.0
point 1 Rendova-Rano 157.32886 -8.62969 0.0 -0.50 0.10 1.0
point 1 Rendova-Vankuva 157.33953 -8.60934 0.0 0 0.10 1.0
point 1 Rendova-Kofi_Bay_village 157.33874 -8.6039 0.0 -0.40 0.10 1.0
point 1 Rendova-Mauru_Loging_Camp 157.39881 -8.5137 0.0 -0.30 0.10 1.0
point 1 Rendova-Ugele 157.39921 -8.44959 0.0 0 0.10 1.0
Modeled Fault: We need to come up with a choice for the appropriate input model. This can be done using existing published fault geometries, evaluating distributions of microseismicity, focal mechanisms, examination of surface topography/bathymetry, or some combination of these methods. Once an initial model is chosen, output from a number of inversions using differing geometries can be used to chose an optimal geometry by evaluating each geometry's overall model fit. The output results of these inversions can then be broken up into distributed models (discussed below).
Here, Newman et al. (2011) defined the fault using a combination of the overall fault strike, and testing a range of dip geometries.
For our inversion, we will define a finite range of allowble thrust(+) values (ds, and dX between 0 and 100 m).
Because data here are only vertical, we will chose to set strike-slip to 0 and not allow it to vary in the model, as this component will be very poorly constrained, possibly being dependent on choice of geometry. Finally, because this is a uniform slip model, the number of slip and strike components must be set to one (Nd=Ns=1).
Note: Here, the dip =158° for a strike of 125°. This is equivelent to a dip of 22° striking 305°, but from the far end-point.
#fault type name lon lat z1 z2 len str dip ss ds ts ss0 ssX ds0 dsX ts0 tsX Nd Ns
fault 1 slm 157.0990 -8.6920 0 5200 50000 125.0 158.0 0 0.1 0 0 0 0 100 0 0 1 1
Run: After combining the above parameters into a single input file (e.g. 'solomon.in'), you can run the code just as was done in the forward model.
Output:
- Output files: If the model converges, you can analyze the output results in either the '_inv.out' or '_kp*.out'.
The former file gives the fit results of the run, while the later gives the model results as well as their predicted displacements at the sites described in the orginal input model. Its this second file that can be used as an input for future runs.
- Model fit: Below is the output from 'solomon_inv.out' created by GTdef. Since there is only one inversion ran, there will be only one data line following a header line preceded by its column number (#).
#(1)beta (2)kappa (3)data_num (4)slip_num (5)ndf (6)rss [m^2] (7)rms [m] (8)wrrs [m^2] (9)wrms [m] (10)chi2 (11)rchi2 (12)r_1d [cm/km] (13)r_2d [cm/km^2] (14)strain [cm/km]
0.00000e+00 0.00000e+00 14 1 13 4.05607e-01 1.70211e-01 4.05607e+01 1.70211e+00 4.05607e+01 3.12005e+00 NaN NaN NaN
- Model results and predicted displacements: Shown here is the output from 'solomon_kp0.00000.out'. Note that in addition to lines repeating the input file, there are several default input options explicitely written out here (e.g. coord, earth, surface). Also included are model misfits repeated from the above file. Lastly, the model line now includes the model output for a best-fit (showing 5.16091 m of thrust), and the model predictions for each data line (e.g. Rendova-Mbaniata predicts 62.62 cm of subsidence).Though data type was input as point 1, they are output as point 3, giving the predicted horizontal motions as well. Errors are not reported for models.
coord geo
#data_num 14
#slip_num 1
#ndf 13
#rss 4.05607e-01 [m^2]
#rms 1.70211e-01 [m]
#wrss 4.05607e+01 [m^2]
#wrms 1.70211e+00 [m]
#chi2 4.05607e+01
#rchi2 3.12005e+00
#r_1d NaN [cm/km]
#r_2d NaN [cm/km^2]
#strain NaN [cm/km]
earth homogeneous 3.00e+10 0.2500
kappa 0.00000
beta 0.00000
smooth 2d
surface free
fault 1 slm<PHONE_NUMBER>0 -8.69200000 0.0000e+00 5.2000e+03 5.0000e+04 125.00 158.00 0.00000 5.16091 0.00000 0.0000 0.0000 0.0000 100.0000 0.0000 0.0000 1 1
point 3 Rendova-Rendova_Harbor<PHONE_NUMBER>0 -8.40359000 0.00000e+00 -0.09951 -0.25301 0.00474 NaN NaN NaN 1.00
point 3 Rendova-Epata_Creek<PHONE_NUMBER>0 -8.43730000 0.00000e+00 -0.11693 -0.31236 -0.00387 NaN NaN NaN 1.00
point 3 Rendova-Mbaniata<PHONE_NUMBER>0 -8.63325000 0.00000e+00 -0.89590 -1.40681 -0.62620 NaN NaN NaN 1.00
point 3 Rendova-Hofofo_Pt<PHONE_NUMBER>0 -8.56530000 0.00000e+00 -0.26215 -0.92622 -0.30033 NaN NaN NaN 1.00
point 3 Rendova-Habila<PHONE_NUMBER>0 -8.60414000 0.00000e+00 -0.70254 -1.31715 -0.55581 NaN NaN NaN 1.00
point 3 Rendova-Rava_Pt<PHONE_NUMBER>0 -8.72264000 0.00000e+00 -0.98978 -1.39069 -0.60162 NaN NaN NaN 1.00
point 3 Tetepare-Tofa<PHONE_NUMBER>0 -8.75576000 0.00000e+00 -0.71027 -0.73619 -0.19750 NaN NaN NaN 1.00
point 3 Tetepare-Jetty_near_Ecolodge<PHONE_NUMBER>0 -8.72234000 0.00000e+00 -0.87663 -1.18799 -0.39089 NaN NaN NaN 1.00
point 3 Tetepare-Ecolodge_boat_ramp<PHONE_NUMBER>0 -8.72120000 0.00000e+00 -0.86957 -1.17774 -0.38133 NaN NaN NaN 1.00
point 3 Rendova-Rano<PHONE_NUMBER>0 -8.62969000 0.00000e+00 -0.73815 -1.12756 -0.30286 NaN NaN NaN 1.00
point 3 Rendova-Vankuva<PHONE_NUMBER>0 -8.60934000 0.00000e+00 -0.59654 -0.93641 -0.17707 NaN NaN NaN 1.00
point 3 Rendova-Kofi_Bay_village<PHONE_NUMBER>0 -8.60390000 0.00000e+00 -0.57048 -0.90517 -0.16057 NaN NaN NaN 1.00
point 3 Rendova-Mauru_Loging_Camp<PHONE_NUMBER>0 -8.51370000 0.00000e+00 -0.24266 -0.41934 -0.00177 NaN NaN NaN 1.00
point 3 Rendova-Ugele<PHONE_NUMBER>0 -8.44959000 0.00000e+00 -0.15468 -0.29970 0.00941 NaN NaN NaN 1.00
- Predicting displacements elsewhere: To estimate model displacements outside of the original data points in '_kp*.out', you can copy the model output into a new file along with the points that you want prediced. Here, we are just using a grid, similar in the foward model example above, name it something like 'solomon_fwd.in', and run as before.
#fault type name lon lat z1 z2 len str dip ss ds ts ss0 ssX ds0 dsX ts0 tsX Nd Ns
fault 1 slm 157.09896 -8.69204 0.00e+00 5.20e+03 5.00e+04 125.00 158.00 0.000 5.167 0.000 0.00 0.00 0.00 0.00 0.00 0.00 1 1
#grid name Erot Nrot lon1 lat1 lon2 lat2 Ne Nn
grid Solom_region 0 0 156.4 -9.3 158.1 -7.9 200 200
Plotting results:
- One tool that is particularly useful is the supplied algorithm 'GTdef_project', as it can take the predicted output model and transform it into a highly-readable file for your favorite plotting program.
> % within matlab
> GTdef_project('solomon_kp0.00000.out')
This creates a new file (here 'solomon_kp0.00000_patches.out') that describes all elements (here only one) of the model, including geographic position of corners, the element center position, and slip values.
While you could use a more full-featured plotting program like GMT, we'll again use gnuplot for our quick and dirty plot to show the predicted displacements from '_kp*.out', and then model geometry from '_kp*_patches.out'.
# within gnuplot
# Note: We are using diffential scaling of the displacement vectors to scale with the geographic position and depth (in degrees° and km)
gnuplot> splot "< awk '$1==\"point\"{print $0}' solomon_kp0.00000.out"\
u 4:5:(0):($7*1e-1):($8*1e-1):($9*1e1) w vect t "surface displacement",\
"< awk '$1==\"slm\"{printf \"%f %f %f\\n%f %f %f\\n%f %f %f\\n%f %f %f\\n%f %f %f\\n\", $4,$5,-$6/1000,$7,$8,-$9/1000,$10,$11,-$12/1000,$13,$14,-$15/1000,$4,$5,-$6/1000}' solomon_kp0.00000_patches.out"\
w l lw 4 lt 7 -8 t "fault"
- After using your pointer to move around your model appropriately, your result should look something like this:
-
(from 'examples/Non-uniformslip/Solomon')
This problem is a little more tricky, as we will quickly go from an overdetermined problem (more data than model paremeters),
to an underdetermined problem.
In order to get around this, and to solve for realistic slip, we constrain the interdependence between individual slip patches.
The most popular way to do this is to define minimize the 'roughness' of the slip patch, as defined in
Harris and Segall (1987),
but more concisely in Jónsson_et al_(2002).
The method works to minimize the 2D second-order derivative of the slip surface so that large changes are constrained within a certain value.
The way it's been implemented here is that a series of roughness solutions are determined, all yielding different misfits to the data.
It is a somewhat arbitrary decision to chose the optimal roughness parameter. Usually this is done by evaluating the kink-point by which
additionally smooth results significantly increase misfits.
Input
- Choose your kappa value (parameter that controls roughness) to range between 0 to 5000 by 500.
- Setup your fault to now have 70 subfaults, 7 patches along-strike and 10 patches along-dip.
#fault type name lon lat z1 z2 len str dip ss ds ts ss0 ssX ds0 dsX ts0 tsX Nd Ns
fault 1 slm 157.0990 -8.6920 0 5200 50000 305.0 22.0 0 0.1 0 0 0 0 100 0 0 7 10
Run
- Within Matlab, run GTdef('solomon_inv.in') like in the example above except this time you're running an inversion due to the way the fault parameters are set up.
Output
- This time, you have two kinds of output files, those that end in '_kp*' correspond to each kappa value you set in step "i" above, and the other is a summary file '_inv.out'. The inversion summary file will be used in the next step to determine the optimal smoothing factor (kappa value) for this dataset.
- Explore your inversion results. Using GTdef_misfit_kappa.gmt, try plotting misfit vs. roughness to see how your choices in kappa affect these results. Looking at the L-curve, the 4th lowest kappa value is optimal for this example dataset.
# in shell (command line)
GTdef_misfit_kappa.gmt -M nicoya_camp_inv_inv.out
Plotting results:
- Finally, once you've chosen your optimal kappa value, run a new forward model, and repredict deformation. The new forward model input will be a modified version of the corresponding '_kp.out' file to the optimal kappa value determined from the step above. Remember, for a forward model, it is important that all slip parameter ranges for a given slip-type on a fault block have equal value (i.e. ss0=ssX, ds0=dsX, and ts0=tsX).
- You might want to look at your results in a geographic reference system. We've created a GMT script (GTdef_slipmodel.gmt) to do this,
but you may need to modify it for your purposes.
# in shell (command line)
GTdef_slipmodel.gmt -M solomon.in -K750 -R157.0/157.7/-9/-8.3 -S0.1/1/0.1 -D
Here is an example of a plot from the results obtained with an inversion with kappa=750.
-
(from 'examples/Non-uniformslip/Nicoya/Checkboard')
Develop a Synthetic Forward Model:
- Define the size boxes that you will want to try to recreate in your checkerboards.
As a general rule, we find that the model patch size that you can interpret is dependent on and about equal to its depth relative to stations overhead.
This assumes stations are immediately overhead.
This will certainly change as a function fault dip, and station coverage, thus while you may have theoretical fidelity to recover even extremely small
patches near the trench (where the fault is just below you), you may not have data until you're on land, 50 to 200 km away.
Thus, we will take an initial example of a fault patch that is 50 km laterally from a 20° dipping fault surface,
the checkerboard patch should be around 50km*sin(20°)=17km . At 100 km, it's about 34 km, and at 200 km it's about 70 km, assuming constant dip.
Note, that this is just a starting and approximate parameter.
- You will now need to define a number of subfaults that match your expected optimal resolution.
This too can be done by hand, but the program, GTdef_ckbd_subflt.m makes it much easier.
Check out the header notes within the program for details.
- For a fault named 'nicoya' with 30x40 patches and approximately 200 km x 200 km in size,
you can run
% within matlab
GTdef_ckbd_subflt('nicoya',30,40,3,4, [0 -.0823 0 0 0 0 0 0 0],[0 0 0 0 0 0 0 0 0])
to define a fault that groups alternating blocks into 3 along dip, and 4 along strike patches. Here, the
the blocks are 20x20 km (smallest size for coastal data--this is too small for deeper patches).
The vectors here define the forward behavior of the patches that we normally think of as 1's and 0's.
So, patch 1 (the black, or slipping patch), p1= is only backthrust at 82.3 mm (no inversion set for these patches).
For patch 0 (the white, or null patch), p0= zeros (9 of them).
The program will create a file called GTdef_ckbd_subflt.out that will only contain the sub-fault parameters.
This will need to be copied into your input model file that contains your fault characterization
and 'points' in which you want to predict deformation for the forward run.
# in shell (command line)
cat GTdef_ckbd_subflt.out >> nicoya_ckbd.in
- Once it's ready, run
% within matlab
GTdef('nicoya_ckbd.in')
If everything works you will get your initial noise-free synthetics.
- Using GTdef_slipmodel.gmt, plot the noise free model with the nicoya_ckbd_fwd.out
(the output from the forward run).
# in shell (command line)
GTdef_slipmodel.gmt -M nicoya_ckbd.in -S100/100/10
The figure should look like the example below.
Note, that because this program is written for real data, the labeling may not be accurate. Here, 'observed' is arbitrary, and
whatever was in your original input file. Modeled data are the predicted results that will be used for subsequent inversions.
Adding Noise:
Good synthetic data includes an approximation of the noise that you'd get in the real data.
For this, We've developed a simple shell script that searches only point data from an output
file and adds Gaussian noise to the data itself.
The program then writes out the perturbed data and error estimates representing the input error,
of the size defined within the script.
This program needs updating for easier and general use, but it's pretty easy to run, as is.
- Copy the program to your working directory (its called add_noise.sh and is in the
plotting directory shared with the GTdef scripts).
- Edit the parameters at the top of the file to include the expected
East, North, and Vertical noise in your data (in meters).
Now run it it on the output file, directing into a new output.
As an example:
# in shell (command line)
add_noise.sh nicoya_ckbd_fwd.out > nicoya_ckbd_fwd_wNOISE.in
Note that the directed output is now ending in '.in'.
Invert Synthetics:
Here we will determine what the synthetic and noised data show on the fault.
- Edit new synthetic input file to either comment out or remove the sub-fault definitions.
You can do this manually, or run a script:
# in shell (command line)
# this scrubs file directing it into a new file that then replaces the original.
grep -v subfault nicoya_ckbd_fwd_wNOISE.in > j1 ; mv j1 nicoya_ckbd_fwd_wNOISE.in
- You can add or modify any other parameters that you want into the header of the file input file.
We want to be sure that we're running a range of kappa values.
Here it's 5 between 1000-5000, 5 between 7k and 15k, and 4 between 20k and 50k, but the useful range
depends on the number of patches and relation to data.
Modify nicoya_ckbd_fwd_wNOISE.in to include:
surface free # slip to the trench here
kappa 2 1000 5000 5 # 1k-5k for with n=5
kappa 2 7000 15000 5 # every 2k now
kappa 2 20000 50000 4 # every 10k now
resolution 1 # output the results of the resolution matrix (we can use later)
lsqlin 10 1e-10 # less iterations and higher tolerance limits (faster runs with no real degradation).
project on # runs through and creates easy to read geographically projected outputs of model and slip parameters.
Change the fault line to invert (e.g. make thrust range from -0.823 to 0, the ds0 and dsX values).
#fault is set for inversion (ds0, dxX = 0, -.0823)
#fault type name lon1 lat1 lon2 lat2 z1 z2 dip ss ds ts ss0 ssX ds0 dsX ts0 tsX Nd Ns
fault 2 nicoya -85.54233907 8.74026277 -86.82826920 10.01077299 0 6.2e+04 17.0 0 -0.0823 0 0 0 -0.0823 0 0 0 30 40
- Run the inversion:
% within matlab
GTdef('nicoya_ckbd_fwd_wNOISE.in')
- Determine appropriate Κ value to use by evaluating the information in 'nicoya_ckbd_6x8_fwd_lowNOISE_inv.out', which
can be plotted with GTdef_misfit_kappa.gmt.
# in shell (command line)
GTdef_misfit_kappa.gmt -M nicoya_ckbd_3x4_fwd_lowNOISE_inv.out
Results are
here.
- Now, evaluate/visualize the results of the inversion to determine which patches have better or worse representation
of the original input model that you created (your checkerboards).
A great way to do this is to create very similar plots of both the result of the forward prediction (nicoya_ckbd_fwd.out)
and the new inverse at the kappa that you feel most appropriate (e.g. nicoya_ckbd_fwd_wNOISE_k9000.out).
Now the files should be ready for the helper program GTdef_slipmodel.gmt.
# in shell (command line)
GTdef_slipmodel.gmt -M nicoya_ckbd_fwd_lowNOISE.in -K 9000 -S100/100/10
The figure should look like the example below.
Notes:
As you can see in the above figure, the checkerboards are only replicated near the coast, and the predicted model becomes
smooth with apparent larger patches both up-dip and down-dip, denoting loss of resolvability from a lack of stations immediately overhead (updip),
and insufficiently large patches sizes (downdip).
To improve on the down-dip problem, it is possible to make a hybrid checkerboard model with larger down-dip patches
(maybe 40x40 km), to test the resolution of larger slip features.
When doubling the patch sizes, features are much better resolved (in 'examples/Non-uniformslip/Nicoya/Checkboard/Nicoya6x8patches').
- input checkerboard
- trade-off curve
- inversion results
- Checkerboard testing is relatively straightforward, but a somewhat cumbersome problem with a visual and not very quantitative
assessment of the model quality given data. Instead, it may be much better to look at the output of the resolution matrix, itself.
- The examples used in the checkerboard tests above use campaign data from the Nicoya Seismic Cycle Observatory GPS data.
-
Theory:
If you've ran inversions with the 'resolution' flag set to one (see option in Checkerboard Testing section), we
should have outputs with the tail '_patches_R.out' for each of the kappa values in our models. This file describes the output of
the diagonals of the model resolution matrix, Rjj, as the product of the Generalized Inverse Matrix and the Green's function (see Theory section).
(9)
R = G-gG
Equation(7) from above can be rewritten as:
(10)
G-g = [GTWeG+ ρWm]-1GTWe
where Wm is the Laplacian of the slip, We is the error weighting matrix, and ρ is the roughness intensity applied to the models
(Jonsson et al., 2002; Kyriakopoulos and Newman, 2016).
From the diagonals of the resolution matrix, Rjj,
you can get a characterization of how spatially a model patch's resolution is spread output across the model space.
This can be related in a single scalar per patch that is dependent on the patch size.
This parameter is called the resolution spread, rj, and is
(11)
rj = Lj / √Rjj,
where Lj is the nominal patch size (Funning et al., 2005; Kyriakopoulos and Newman, 2016).
Because R doesn't depend on the actual values of the data, but only its location and weighted errors, relative to the model,
the same is true for rj.
Evaluation:
(from 'examples/Non-uniformslip/Nicoya/Checkboard')
We've created a program that calculates Lj, and rj for a selected component of slip.
The program GTdef_Rmodel.gmt uses similar inputs to GTdef_slipmodel.gmt, but requires Kappa (-K) and Slip components (-C) to be described.
As noted above, the program requires the respective '_patches_R.out' files that are created with the c>'resolution' flag set to 1 before an inversion.
# in shell (command line)
GTdef_Rmodel.gmt -M nicoya_ckbd_fwd_lowNOISE.in -K7000 -S D -D
This will plot the dip-slip (-S D) component, at Κ=7000, displaying the result (-D).
The figure should look similar to the example below.
The real beauty of the Resolution Spread is in it's simplicity and quantitative nature. Instead of creating apriori assessments
of approximate resolvable model size, developing a model/running it, and doing "squinty-eyed" qualitative analysis of what you can
resolve (as is done with Checkerboard testing), you get real numbers, with direct resolvable properties of patch size.
While plotting rj gives a direct image of all patches average spread, you can use resolution 2 to
get information on the off-diagonal components of the model resolution matrix to plot the actual spatial smearing of individual
patches, per component (see Kyriakopoulos and Newman, 2016). You may need to develop your own plotting algorithm for this.
-
In the examples above, we've been working with a homogeneous elastic half-space. In this section, we will describe another set of algorithms for creating layered models within GTdef.
The algorithms GTdef_edgrn.m and GTdef_edcmp.m, create the Green's functions and compute the expected deformation, respectively.
The codes are adopted from Wang et al.(2003), originally written in FORTRAN.
Input
(from 'examples/Layered_Models/Nicoya/All_stations')
To build an input file to run the layered model it is necessary to set the earth structure to be 'layered'
and define appropriate parameters for the desired layers.
Details are included in the example input file. The layer parameters are defined as follows;
# nl - number of lines of layer information (!= number of layers)
# each layer except the top layer (interface of halfspace) has two lines of records
# if upper & lower values are different, layers will be treated as constant gradient
# obsz - uniform depth of observation points [m]
# nr - number of radial points for green functions
# minr - minimum radial distance [m]
# maxr - maximum radial distance [m]
# nz - number of depth points for green functions
# minz - minimum depth (positive points down) [m]
# maxz - maximum depth (positive points down) [m]
# srate - sampling rate for wavenumber integration
# the ratio between the Nyquist wavenumber and the really used wavenumber
# suggested value 10-128 {12}
# the larger the value is, the more accurate the results are, more time required
#earth layered nl obsz nr minr maxr nz minz maxz srate
earth layered 22 0.0 1201 0.0 300e3 326 0.0 65e3 12
Run
For this example, we use a combination of Campaign and Continuous stations from the Nicoya dataset.
The layers are defined by Vp, Vs, depth and density (rho),
in this example we use an initial 1-D best-fit velocity model specific to the region as published in
DeShon et al.(2006).
In this example, each layer has internally constant properties, and are described from shallowest to deepest.
The bottom layer defines everything underneath it.
Keep in mind that each line is the layer boundary conditions, and not conditions across the entire layer.
A complete input file can be found in the examples directory (Layered_models). The first 5 lines are shown below:
#layer id depth Vp [m/s] Vs [m/s] rho [kg/m^3]
layer 1 0.0e3 5.35e3 3.01e3 2646.291
layer 2 5.0e3 6.12e3 3.44e3 2736.762
layer 3 5.0e3 6.12e3 3.44e3 2736.762
layer 4 9.0e3 6.12e3 3.44e3 2736.762
layer 5 9.0e3 6.12e3 3.44e3 2736.762
After the model is set up, the model can be run the same way as other models:
% within matlab
GTdef('nicoya_all_stations_inv.in')
Output
Since this is set up to run an inversion, the output files will be the same type ('_kp*.out')
however it too will create outputs for the algorithms' Green's functions by default.
The GTdef_edgrn.m algorithm will generate these and store them in a subdirectory called ./edgrnsfcts.
The directory will contain three large files describing each strike-slip (ss), dip-slip (ds), and the compensated linear vector dipole (cl).
Once the files are created, you can change the fault and station geometry minding not to go beyond the depth and distance limits established
in the earth layered line.
Plotting results
Using the gmt plotting programs introduced in the sections above,
we can plot the misfit curve and the geographic representation of the slip and deformation estimates.
# in shell (command line)
GTdef_slipmodel.gmt -M nicoya_allstations_layered_inv.in -K15000 -D
For the Nicoya Dataset and the layered model, a representative result is shown below.
For comparison, we include the Okada solution
for the same fault geometry and data.
-
(from 'examples/Joint_Inversion/3_Tsunami')
(to be complete)
-
- Santamarina, J. C., & Fratta, D. (2005). Discrete signals and inverse problems. An Introduction for Engineers and Scientists. UK: Wiley & Sons.
- Menke, W. (2012). Describing inverse problems.
- Wang, R., Martı́n, F. L., & Roth, F. (2003). Computation of deformation induced by earthquakes in a multi-layered elastic crust—FORTRAN programs EDGRN/EDCMP. Computers & Geosciences, 29(2), 195-207.
- Funning, G. J., Parsons, B., Wright, T. J., Jackson, J. A., & Fielding, E. J. (2005). Surface displacements and source parameters of the 2003 Bam (Iran) earthquake from Envisat advanced synthetic aperture radar imagery. Journal of Geophysical Research: Solid Earth, 110(B9).
- Kyriakopoulos, C., & Newman, A. V. (2016). Structural asperity focusing locking and earthquake slip along the Nicoya megathrust, Costa Rica. Journal of Geophysical Research: Solid Earth, 121(7), 5461-5476.
- Okada, Y. (1985). Surface deformation due to shear and tensile faults in a half-space, Bull. Seism. Soc. Am. 75, 1135-1154.
- Chen, T., A. V. Newman, L, Feng, H. M. Fritz (2009), Slip Distribution from the 1 April 2007 Solomon Islands Earthquake: A Unique Image of Near-Trench Rupture, Geophys. Res. Lett., 36, L16307, doi:10.1029/2009GL039496.
- Feng, L., A. V. Newman, J. M. Protti, V. González, Y. Jiang, T. H. Dixon (2012), Active Deformation near the Nicoya Peninsula, Northwestern Costa Rica, Between 1996 and 2010: Interseismic Megathrust Coupling, J. Geophys. Res., 117, B06407, doi:10.1029/2012JB009230.
- DeShon, Heather R., et al. "Seismogenic zone structure beneath the Nicoya Peninsula, Costa Rica, from three-dimensional local earthquake P-and S-wave tomography." Geophysical Journal International 164.1 (2006): 109-124.
|


---
# Feel free to add content and custom Front Matter to this file.
# To modify the layout, see https://jekyllrb.com/docs/themes/#overriding-theme-defaults
title: FoxDeploy Archives 2021
food: Pizza
layout: page
show_sidebar: true
hero_image: /assets/images/foxdeployMOUNTAINTOP_hero.webp
---
{% assign postsForYear = site.posts | group_by_exp:"post", "post.date | date: '%Y'" | where: "name", "2021" %}
Posts for year {{ postsForYear[0].name }}, total posts {{ postsForYear[0].size }}
All Posts for {{ postsForYear[0].name }}
{% for post in postsForYear[0].items limit:5 %}
{{ post.date | date: '%B %d, %Y' }}
FoxDeploy
{{ post.excerpt }}
Continue Reading...
{% for tag in post.tags %}
{% include tag.html tag=tag %}
{% endfor %}
{% endfor %}


From the Death Certificate
for Sarah C. Herlan
Sarah C. Herlan
Death certificate #57353 was
issued in Newport Township of Washington County, Ohio. Sarah C. Herlan, widowed from Jacob Herlan,
was born Mar. 7, 1850. She lived 73
years 6 months and 8 days. She did
housework. She was born in Washington
Co., Ohio, the daughter of John McCoy
from Pa. and Mary Scott from Pa. Mrs.
R.G. Hughes of Eureka, W Va. was the informant. [Sarah had a daughter Sadie who was married to Robert Hughes.]
Dr. E. W. LeFever signed that she died Sept 15, 1923, from intersusception of
the bowels from which she had been suffering for seven days. She was buried in Beech Grove cemetery in Marietta, Ohio, on Sept. 18th, 1920.
Provided by Betty Latta Kitchen
Click here for the Short-Cut Table of Contents


--- layout: splash header: image: "/images/GeoShapes_croped(Mathew Overton).png" caption: "Image credit: [**Unsplash**](http://simpledesktops.com/browse/)" classes: wide ---
A few interesting things about me. I love to read about personal investments (My personal favorite book is "The total money makerover" by Dave Ramsey). I am also photographer. Lastly, I love learning. Every day I push myself to learn something new, whether that be about machine learning, software engineeriing, or miscellaneous facts about the universe. I am a Data Science Analyst working in fintech startup called Defynance, where I used data science and machine learning to solve business problems.
Take a look at some of the things I love working on.
I love telling a story. Making a beautiful and compelling presentation is one of my favorite skills.
I have worked with researchers to apply NLP techniques to make sense of the motivations behind human interactions.
Machine learning is more than an API call to scikit-learn. I love the math and theory as well as the implementation.
I have developed several web scrapping API's and web automation algorithms. I enjoy innovative use of web automation.
I love using data science to develop tools to help getting insights from personal finances and smart investmenting.
I love finding bottle necks and finding innovative solution to optimize the process. I even have six sigma certfication.
4 - Advanced 5 - Expert