|
ProcessMemoryUtilities.Net
1.3.0
|
Provides access to some methods of ntdll.dll More...
Static Public Member Functions | |
| static uint | RtlNtStatusToDosError (uint value) |
| Converts the specified NTSTATUS code to its equivalent system error code. More... | |
| static bool | NtSuccess (uint value) |
| Checks if the specified NTSTATUS is a success or informational type. More... | |
| static bool | NtSuccessOnly (uint value) |
| Checks if the specified NTSTATUS is a success type. More... | |
| static bool | NtInformation (uint value) |
| Checks if the specified NTSTATUS is a informational type. More... | |
| static bool | NtWarning (uint value) |
| Checks if the specified NTSTATUS is a warning type. More... | |
| static bool | NtError (uint value) |
| Checks if the specified NTSTATUS is a error type. More... | |
| static uint | NtClose (IntPtr handle) |
| Closes an open object handle. More... | |
| static uint | NtOpenProcess (ProcessAccessFlags desiredAccess, int processId, out IntPtr handle) |
| Opens an existing local process object. More... | |
| static uint | NtOpenProcess (ProcessAccessFlags desiredAccess, bool inheritHandle, int processId, out IntPtr handle) |
| Opens an existing local process object. More... | |
| static uint | NtReadVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size, IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemory< T > (IntPtr handle, IntPtr baseAddress, ref T buffer) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemory< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, int length) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, int length, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, int length) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, int length, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtReadVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, out IntPtr numberOfBytesRead) |
| ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtAllocateVirtualMemory (IntPtr handle, IntPtr size, AllocationType allocationType, MemoryProtectionFlags memoryProtection, out IntPtr address) |
| Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The function initializes the memory it allocates to zero. More... | |
| static uint | NtFreeVirtualMemory (IntPtr handle, IntPtr address, IntPtr size, FreeType freeType) |
| Releases, decommits, or releases and decommits a region of memory within the virtual address space of a specified process. More... | |
| static uint | NtProtectVirtualMemory (IntPtr handle, IntPtr address, IntPtr size, MemoryProtectionFlags newProtection, out MemoryProtectionFlags oldProtection) |
| Changes the protection on a region of committed pages in the virtual address space of a specified process. More... | |
| static uint | NtWriteVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size, IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemory (IntPtr handle, IntPtr baseAddress, IntPtr buffer, IntPtr size) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemory< T > (IntPtr handle, IntPtr baseAddress, ref T buffer) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemory< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, int length) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, int length, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, int offset, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryArray< T > (IntPtr handle, IntPtr baseAddress, T[] buffer, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, int length) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, int length, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
| static uint | NtWriteVirtualMemoryPartial< T > (IntPtr handle, IntPtr baseAddress, ref T buffer, int offset, out IntPtr numberOfBytesWritten) |
| WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails. More... | |
Provides access to some methods of ntdll.dll
|
static |
Reserves, commits, or changes the state of a region of memory within the virtual address space of a specified process. The function initializes the memory it allocates to zero.
| handle | The handle to a process. The function allocates memory within the virtual address space of this process. The handle must have the PROCESS_VM_OPERATION access right.For more information, see Process Security and Access Rights. |
| size | The size of the region of memory to allocate, in bytes. |
| allocationType | The type of memory allocation. Common flags are AllocationType.Commit | AllocationType.Reserve. |
| memoryProtection | The memory protection for the region of pages to be allocated. If the pages are being committed, you can specify any one of the memory protection constants. |
| address | A pointer to a variable that receives the base address of the allocated region of pages. |
|
static |
Closes an open object handle.
| handle | A valid handle to an open object. |
|
static |
Checks if the specified NTSTATUS is a error type.
| value | A NTSTATUS value. |
|
static |
Releases, decommits, or releases and decommits a region of memory within the virtual address space of a specified process.
| handle | A handle to a process. The function frees memory within the virtual address space of the process. The handle must have the PROCESS_VM_OPERATION access right.For more information, see Process Security and Access Rights. |
| address | A pointer to the starting address of the region of memory to be freed. If the dwFreeType parameter is MEM_RELEASE, lpAddress must be the base address returned by the VirtualAllocEx function when the region is reserved. |
| size | The size of the region of memory to free, in bytes. If the dwFreeType parameter is MEM_RELEASE, dwSize must be 0 (zero). The function frees the entire region that is reserved in the initial allocation call to VirtualAllocEx. If dwFreeType is MEM_DECOMMIT, the function decommits all memory pages that contain one or more bytes in the range from the lpAddress parameter to (lpAddress+dwSize). This means, for example, that a 2-byte region of memory that straddles a page boundary causes both pages to be decommitted. If lpAddress is the base address returned by VirtualAllocEx and dwSize is 0 (zero), the function decommits the entire region that is allocated by VirtualAllocEx. After that, the entire region is in the reserved state. |
| freeType | The type of free operation. This parameter can be one of the FreeType values. |
|
static |
Checks if the specified NTSTATUS is a informational type.
| value | A NTSTATUS value. |
|
static |
Opens an existing local process object.
| desiredAccess | The access to the process object. This access right is checked against the security descriptor for the process. This parameter can be one or more of the process access rights. |
| processId | The identifier of the local process to be opened. |
| handle | A variable that receives the opened handle. |
|
static |
Opens an existing local process object.
| desiredAccess | The access to the process object. This access right is checked against the security descriptor for the process. This parameter can be one or more of the process access rights. |
| inheritHandle | If this value is TRUE, processes created by this process will inherit the handle. Otherwise, the processes do not inherit this handle. |
| processId | The identifier of the local process to be opened. |
| handle | A variable that receives the opened handle. |
|
static |
Changes the protection on a region of committed pages in the virtual address space of a specified process.
| handle | A handle to the process whose memory protection is to be changed. The handle must have the PROCESS_VM_OPERATION access right. For more information, see Process Security and Access Rights. |
| address | A pointer to the base address of the region of pages whose access protection attributes are to be changed. All pages in the specified region must be within the same reserved region allocated when calling the VirtualAlloc or VirtualAllocEx function using MEM_RESERVE. The pages cannot span adjacent reserved regions that were allocated by separate calls to VirtualAlloc or VirtualAllocEx using MEM_RESERVE. |
| size | The size of the region whose access protection attributes are changed, in bytes. The region of affected pages includes all pages containing one or more bytes in the range from the lpAddress parameter to (lpAddress+dwSize). This means that a 2-byte range straddling a page boundary causes the protection attributes of both pages to be changed. |
| newProtection | The memory protection option. This parameter can be one of the MemoryProtectionFlags. |
| oldProtection | A pointer to a variable that receives the previous MemoryProtectionFlags of the first page in the specified region of pages. |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| size | The number of bytes to be read from the specified process. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. If lpNumberOfBytesRead is IntPtr.Zero, the parameter is ignored. |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| size | The number of bytes to be read from the specified process. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| size | The number of bytes to be read from the specified process. |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. If lpNumberOfBytesRead is IntPtr.Zero, the parameter is ignored. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from inside the array to copy to. |
| length | The number of bytes to copy to the array. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from inside the array to copy to. |
| length | The number of bytes to copy to the array. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. If lpNumberOfBytesRead is IntPtr.Zero, the parameter is ignored. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from inside the array to copy to. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | offset | |
| T | : | buffer.Length | |
| T | : | offset |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from inside the array to copy to. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | offset | |
| T | : | buffer.Length | |
| T | : | offset | |
| T | : | out | |
| T | : | numberOfBytesRead |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | buffer.Length |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | buffer.Length | |
| T | : | out | |
| T | : | numberOfBytesRead |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| length | The number of bytes to copy to the buffer. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| length | The number of bytes to copy to the buffer. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryPartial | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | ref | |
| T | : | buffer | |
| T | : | offset | |
| T | : | InternalHelper.SizeOf<T>() | |
| T | : | offset |
|
static |
ReadProcessMemory copies the data in the specified address range from the address space of the specified process into the specified buffer of the current process. Any process that has a handle with PROCESS_VM_READ access can call the function. The entire area to be read must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process with memory that is being read. The handle must have PROCESS_VM_READ access to the process. |
| baseAddress | A pointer to the base address in the specified process from which to read. Before any data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for read access, and if it is not accessible the function fails. |
| buffer | A pointer to a buffer that receives the contents from the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| numberOfBytesRead | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtReadVirtualMemoryPartial | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | ref | |
| T | : | buffer | |
| T | : | offset | |
| T | : | InternalHelper.SizeOf<T>() | |
| T | : | offset | |
| T | : | out | |
| T | : | numberOfBytesRead |
|
static |
Checks if the specified NTSTATUS is a success or informational type.
| value | A NTSTATUS value. |
|
static |
Checks if the specified NTSTATUS is a success type.
| value | A NTSTATUS value. |
|
static |
Checks if the specified NTSTATUS is a warning type.
| value | A NTSTATUS value. |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| size | The number of bytes to be written to the specified process. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter is optional. If lpNumberOfBytesWritten is IntPtr.Zero, the parameter is ignored. |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| size | The number of bytes to be written to the specified process. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| size | The number of bytes to be written to the specified process. |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter is optional. If lpNumberOfBytesWritten is IntPtr.Zero, the parameter is ignored. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from inside the array to copy from. |
| length | The number of bytes to copy from the array. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from inside the array to copy from. |
| length | The number of bytes to copy from the array. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified process. This parameter is optional. If lpNumberOfBytesWritten is IntPtr.Zero, the parameter is ignored. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from inside the array to copy from. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | offset | |
| T | : | buffer.Length | |
| T | : | offset |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from inside the array to copy from. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | offset | |
| T | : | buffer.Length | |
| T | : | offset | |
| T | : | out | |
| T | : | numberOfBytesWritten |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | buffer.Length |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryArray | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | buffer | |
| T | : | buffer.Length | |
| T | : | out | |
| T | : | numberOfBytesWritten |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| length | The number of bytes to copy to the buffer. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| length | The number of bytes to copy to the buffer. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryPartial | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | ref | |
| T | : | buffer | |
| T | : | offset | |
| T | : | InternalHelper.SizeOf<T>() | |
| T | : | offset |
|
static |
WriteProcessMemory copies the data from the specified buffer in the current process to the address range of the specified process. Any process that has a handle with PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process to be written to can call the function. Typically but not always, the process with address space that is being written to is being debugged. The entire area to be written to must be accessible, and if it is not accessible, the function fails.
| handle | A handle to the process memory to be modified. The handle must have PROCESS_VM_WRITE and PROCESS_VM_OPERATION access to the process. |
| baseAddress | A pointer to the base address in the specified process to which data is written. Before data transfer occurs, the system verifies that all data in the base address and memory of the specified size is accessible for write access, and if it is not accessible, the function fails. |
| buffer | A pointer to the buffer that contains data to be written in the address space of the specified process. |
| offset | A byte offset from the start of the buffer. |
| numberOfBytesWritten | A pointer to a variable that receives the number of bytes transferred into the specified buffer. |
| T | : | unmanaged | |
| T | : | NtWriteVirtualMemoryPartial | |
| T | : | handle | |
| T | : | baseAddress | |
| T | : | ref | |
| T | : | buffer | |
| T | : | offset | |
| T | : | InternalHelper.SizeOf<T>() | |
| T | : | offset | |
| T | : | out | |
| T | : | numberOfBytesWritten |
|
static |
Converts the specified NTSTATUS code to its equivalent system error code.
| value | The NTSTATUS code to be converted. |


Interactive expression coding
Type some expression code below and click on the run button to execute
define: percentage of {a} to {b} is {d} a / b = d d * 100 = c concat c and % to give d main: percentage of 5 to 25 is c print c c * 16 = d percentage of c to d is e print e
Run


7. Processing and Accessing the Results¶
7.1 Outputs of the forward simulations¶
Once your job has run, you will be able to access the output of the simulation in three ways:
Clicking on the ‘Control’ tab in the ‘Simulation’ section of the ‘Forward Modelling’ panel (see section 5.7):
It shows a list of the simulation jobs that have been launched with, among others, the corresponding ‘Name’, ‘Description’, ‘Status’ and ‘Date’ of the run; if you do not see the event you have just run then click ‘Refresh list’ to load this in. By clicking on the blue-eye icon next to each run you will be redirected to the ‘Results’ section showing the selected run and all its outputs (in the far left of the opened panel) as described in the next point.
Directly checking under the ‘Results’ section:
The simulation results can be searched using the ‘Open Run’ button which is on the top left. This enables you to search for runs that for instance involve earthquakes in a range of magnitudes (as shown in Figure 7.1), or a range of depths, latitudes, longitudes, etc. For a full list of the parameters for which it is possible to search for, please see the ‘Terms’ drop down menu. You can then select the simulation of interest from the list of previous runs satisfying the searching criteria that appears on the screen after clicking the ‘Search’ button. As in case 1), the far left of the panel will then show the outputs of this simulation.
Using the ‘iRODS’ panel: see section 7.4.
Figure 7.1: Example of searching simulations involving events in a selected magnitude range.
Focusing now on points 1) and 2), selecting an output from the left hand part of the ‘Results’ panel will bring up a provenance diagram in the top right window of the ‘Results’ section marked as ‘Data Dependency Graph’. If this is done for instance for the .kml file that is output, all of the constituent inputs needed for this result are shown by a dark blue circle bounded in yellow, and the outputs are shown by a simple dark blue circle.
The bottom right window, marked as ‘Data products’, gives further details of the output file that is selected and lists possible errors occurred during the production of this output. To open the file concerned, click the blue link marked ‘Open’ or the one marked ‘Download’ appearing in the dialog window. Moreover, with the button ‘Produce Download Script’ you can get a piece of code to download the selected output via gsissh terminal.
Using the ‘Search’ button in the ‘Data products’ section of the ‘Results’ panel it is also possible to search for all the output files of a specific mime-type (e.g., png, kmz, etc.) for a specific simulation.
Finally, you can also visualise the input files for the selected simulation, such as the quakeML file, which contains information about the source or sources that are input into the model. This is done using the ‘View Inputs’ button on the top left of the ‘Results’ panel.
7.1.1 Waveform outputs¶
The primary outputs of any seismic simulation are the recorded waveforms. These can be viewed most simply as a .png file as shown in figure 7.2. To access these figures, after selecting a given simulation (as explained above), use the ‘Search’ button in the ‘Data products’ window (of the ‘Results’ panel) to search for ‘image/png’ type of files. Otherwise, waveforms can be downloaded as seed files searching and downloading ‘application/octet-stream’ mime-type files.
Figure 7.2: Example of waveform output.
The simulation code produces one file for each of the three components of a seismic station and, depending on the Par_file set up (see Appendix 1), the seismograms can be in displacement, velocity or acceleration, or all of them.
The three components of different seismometers that are output can also be viewed in a more interactive form, by downloading the *.kmz file that is automatically output from the simulation run and viewing it in Google Earth as shown in Figure 7.3. This kmz file can be downloaded by searching for a mime-type ‘application/vnd.google-earth.kmz’ in the ‘Search’ section of ‘Data products’.
Figure 7.3: Three components of a synthetic seismogram produced for an earthquake in Central Italy, observed on the interactive Google Earth tool. The seismograms are shown in displacement, velocity and acceleration.
7.1.2 Animation outputs¶
The VERCE platform can also be used to produce animations or movies of the waveforms propagating out from the simulated earthquake event. These animations can be projected onto the Earth’s surface as in the snapshot example of Figure 7.4, or can show the propagation over all the external faces of the mesh (i.e., topography+vertical edges+bottom) depending on the Par_file set up as described in Appendix 1.
The movie file *.mp4 is automatically output from the portal and can be downloaded by searching for a mime-type ‘application/vnd.google-earth.kmz’ in the ‘Search’ section of ‘Data products’ (in the ‘Results’ panel). The animations shown at the top of the movie file and the one on the bottom left (Figure 7.4) represent the three components of the waveform velocity propagation, while the animation at the bottom right is the instantaneous peak ground velocity, i.e. a map of the maximum ground velocity for each time step of the simulation.
Figure 7.4: Snapshot of the movie for an earthquake in Central Italy produced from the VERCE platform using a regional simulation in SPECFEM3D_Globe.
7.1.3 Other outputs¶
The portal outputs can also be processed externally with your own routines to produce, for example, ground motion maps as shown for an event in Northern Italy in Figure 7.5. In particular, this kind of maps can be obtained by processing a binary file called shakingdata produced in output by SPECFEM3D_Cartesian if in the Par_file the user sets the flag
CREATE_SHAKEMAP = .true.
Figure 7.5: A ground shaking map produced with SPECFEM3D_Cartesian for an event occurring in Northern Italy.
One of the main changes that will be introduced in the next release of the portal (autumn/winter 2017) is the automatic production, through a dedicated workflow in the portal, of such ground motion maps, i.e. PGD, PGV and PGA maps. A single *.png picture containing the three maps will be generated from the automatic processing of the shakingdata file.
7.2 Downloading observed data¶
One of the main goals of a seismological analysis is the comparison of simulated results with observed data. Thus, after running a waveform simulation, the portal allows users to download from European data archives the recorded seismograms corresponding to the simulated earthquake.
The section marked as ‘Download’ under the ‘Forward Modelling’ panel is dedicated to this task and it is composed by the following sub-sections that guide the users to launch a data -download job.
’Setup’ tab:
A list of all the simulations that have been run is shown in this window. By selecting one of them, the information on the corresponding earthquake (source location, origin time) and run (NSTEP, DT) are automatically passed to the portal thanks to the metadata stored along with each simulation job.
‘Submit’ tab:
In the upper window you see the input parameters for the download job based on the selection in the previous tab; in the lower window you can setup the submission parameters, in particular the specific workflow and the number of cores of the HPC resource to run the data-download job (see the example in Figure 7.6). Click on ‘Submit’ on the lower right to launch the job.
‘Control’ tab:
As for the case of simulation jobs in section 7.1, this window shows a list of the download jobs that have been launched and their corresponding status, among other information. The ‘blue-eye’ icon next to each run links you again to the main ‘Results’ page where this time you visualize the outputs of the selected data-download job and the provenance graphs.
Otherwise, the outputs can be accessed by searching for the specific download job directly from the ‘Results’ panel (see section 7.1) or from the ‘iRODS’ panel (see section 7.4).
The output files of a data-download job are both seed and png files of the recorded traces downloaded from European archives. Use the ‘Search’ button in the ‘Data products’ window of the ‘Results’ tab to search for mime-type ‘application/octet-stream’ or ‘image/png’, respectively.
Figure 7.6: Example of submission settings for a data-download job.
7.3 Waveform processing¶
Once both a simulation job and a download job have been run, users can exploit another feature of the portal to pre-process observed and synthetic waveforms in order to prepare them for comparison analyses.
In the ‘Forward Modelling’ panel, by clicking on the ‘Processing’ tab you should go through the following sub-sections to set up and launch a processing job.
‘Data Setup’ tab:
The window on the top left shows a list of the waveform simulations that have been run, while the window on the top right shows a list of the data-download jobs that have been run. By selecting a simulation and a download run, a list of the seismic stations involved in the two jobs appears in the window below and the portal automatically highlights the common stations, i.e. those for which both data and synthetics are stored in its database. Use the checkbox on the left of each station to select those for which you are interested in processing both simulated and recorded seismograms in order to then compare them.
‘Processing Setup’ tab:
Here you can built-up a customized pipeline of processing analyses to be applied to the recorded and simulated waveforms selected in the previous panel. A list of the most common seismological processing functions (here called Processing Elements, and abbreviated to PEs) is reported in the far left window. Drag the selected PEs into the top right window following the order of the operations you want to apply on the seismograms.
For each PE of the pipeline you can choose to apply the operation on both data and synthetics or on just one of them using the checkboxes ‘raw’ and ‘synt’. As an example, usually the operation of removing the instrument response (represented by the PE remove_response) is applied only on the raw data, while on the synthetics one applies a pre-filtering function (pre_filter PE) to replicate the bandpass filter done by remove_response function on the data but without any deconvolution (see Figure 7.7). Moreover, the checkbox ‘visu’ allows you to produce a png file showing the result of the specific analysis, while the checkbox ‘store’ allows to also store the processed seismogram as a seed file.
For each PE you can also modify the corresponding parameters. Clicking on the row of a given PE in the ‘PE Workflow’ window, the corresponding parameters appear in the window below and you can set up, for example, the type of de-trend, the type of taper and its percentage, the limit frequencies for the selected filter.
Finally, on the top of the ‘PE Workflow’ window a drop down menu allows to select if the output of the processing will be in displacement, velocity or acceleration, and with a checkbox you can decide to rotate the seismic traces from NS and EW to radial and vertical components.
‘Submit’ tab:
As in the case of section 7.2, this tab shows a summary of the set up for the processing job, in particular the list of stations to which the processing will be applied and a list of the processing operations that compose the custom pipeline. Then, you can setup the submission parameters in the lower window and launch the processing job by clicking on ‘Submit’ on the lower right.
‘Control’ tab:
As previously, the window shows a list of the processing jobs that have been launched and the blue-eye icon links to the main ‘Results’ page where the outputs of the selected job can be explored together with the provenance graphs. The outputs can be also accessed by searching for the specific processing job directly from the ‘Results’ panel (see section 7.1) or from the ‘iRODS’ panel (see section 7.4).
The output products of a processing job can be png files of the processed traces, if the option ‘visu’ is checked, or/and seed files containing the processed seismograms, if the option ‘store’ is on (see above). Use the ‘Search’ button in the ‘Data products’ window of the ‘Results’ tab to search for mime-type ‘image/png’ or ‘application/octet-stream’, respectively.
Figure 7.7: Example of custom pipeline of processing functions to be applied on observed and synthetic seismograms.
7.4 Misfit calculation¶
After simulating the seismic wave field, downloading the raw seismic data and pre-processing both, the VERCE portal allows users to compare synthetic and recorded seismograms and to quantitatively assess the goodness of fit. Evaluating this fit is essential to approach the inverse problem in seismology and there are numerous algorithms and procedures to accomplish this task. In the portal we have so far implemented two different established techniques for misfit calculation and a third option that combines the two:
PYFLEX
This is a python port (L. Krisher; http://krischer.github.io/pyflex) of the fortran code FLEXWIN (Maggi et al., 2009; http://geodynamics.org/cig/software/flexwin). Considering full observed and synthetic traces, the code selects a set of time-windows suitable for waveform comparison based on given input parameters and estimates cross-correlation, time-shift and amplitude ratio within each window. The code allows for an automated selection of the windows handling large data volumes and also complex 3D simulated waveforms, hence it is particularly useful for iterative tomographic inversions (Maggi et al., 2009). For a complete description of the method and the parameters see the manual of PYFLEX (or FLEXWIN).
In the portal this option corresponds to ‘misfit_type = pyflex’.
Kristeková’s misfit method
This is a python code based on the method developed by Kristeková et al. (2006) and Kristeková et al. (2009). The method compares observed and synthetic full-waveforms and allows the following time-frequency (TF) misfit criteria to be estimated:
- time-frequency envelope misfit (TFEM)
- time-frequency phase misfit (TFPM)
- time envelope misfit (TEM)
- time phase misfit (TPM)
- frequency envelope misfit (FEM)
- frequency phase misfit (FPM)
- envelope misfit (EM)
- phase misfit (PM)
This method allows for comparing arbitrary time signals in their entire TF complexity, thus providing a detailed TF anatomy of the disagreement between two full signals from the point of view of both envelope and phase (Kristeková et al., 2009). For a complete description of the method see Kristeková et al. (2006) and Kristeková et al. (2009).
In the portal this option corresponds to ‘misfit_type = time_frequency’.
PYFLEX + Kristeková’s misfit method
In this case the time windows are selected using the code PYFLEX and then the time-frequency misfit criteria are estimated on this windows using Kristekova’s method.
In the portal this corresponds to ‘misfit_type = pyflex_and_time_frequency’.
The section of the VERCE portal for misfit calculation is accessible through the ‘Misfit’ tab in the ‘Forward Modelling’ panel and it consists of the following sub-sections that allows for the set-up of a misfit job.
- ‘Setup’ tab:
Select one of the processing job that have been run and that are listed in the upper window of this panel. Then select the ‘Misfit type’ from the drop-down menu considering that
- ‘pyflex’ corresponds to option 1 above
- ‘time_frequency’ corresponds to option 2 above
- ‘pyflex_and_time_frequency’ corresponds to option 3 above
For each misfit procedure the lower window of the panel shows the corresponding parameters that should be set up by the user. In particular, for option 1 – ‘PYFLEX’ the tuning parameters control the window selection and are fully described in the manual of the code; for option 2 – ‘Kristeková’s misfit method’ the main parameters are the minimum and maximum period at which the waveforms have been filtered; option 3 – ‘PYFLEX + Kristeková’s misfit method‘ contains all the parameters of the two previous options. (See Figure 7.8).
‘Submit’ tab:
A summary of the chosen misfit method and set up parameters is shown in the upper window of this section. Then, you can setup the submission parameters in the lower window and launch the misfit job by clicking on ‘Submit’ on the lower right.
‘Control’ tab:
As always, the window shows a list of the misfit jobs that have been launched and the blue-eye icon links to the main ‘Results’ page where the outputs of the selected job can be explored together with the provenance graphs. The outputs can be also accessed by searching for the specific misfit job directly from the ‘Results’ panel (see section 7.1) or from the ‘iRODS’ panel (see section 7.4).
The output products of a misfit job are png files showing the waveform comparison for each component of each selected seismic station. The figures are different depending on the misfit option chosen in the ‘Setup’ tab (see examples in Figures 7.9 and 7.10). To access these output files use the ‘Search’ button in the ‘Data products’ window of the ‘Results’ tab searching for mime-type ‘image/png’.
Figure 7.8: Example of the set-up of a misfit job using in combination PYFLEX and Kristeková’s method.
Figure 7.9: Example of an output file produced by calculating the misfit using PYFLEX. For each component of each station the figure shows the observed data in black, the synthetic trace in red and the short-term average/long-term average ratio in blue; the windows selected by the code are highlighted.
Figure 7.10: Example of an output file produced by calculating the misfit using Kristeková’s method. For each component of each station the figure shows the observed data in black, the synthetic trace in red; moreover, it shows the Kristeková’s misfi criteria TFEM, TFPM, TEM, TPM, FEM, FPM, EM, PM (see the text for details).
7.4 Accessing the results through iRODS¶
After any of the jobs described above (simulation, download, processing and misfit) is finished, the output products are shipped from the HPC resource, that performed the calculation, to the store repository of the VERCE portal. This storage is managed through iRODS that provides a repository shared among the federated nodes of the VERCE organisation. How to create an account in iRODS is described in section 3 of this manual, and after that you can log in selecting the ‘IRODS’ panel in the portal main menu (see Figure 7.11).
Figure 7.11: Screenshot of the ‘IRODS’ panel in the VERCE portal
Entering iRODS gives you access to your personal folder where you can navigate the results of all your completed jobs (of any type) as anticipated above. The run results are organised in trees of subfolders with the main directory called using the ‘Name’ you have chosen for your job (see section 5.6), as shown for example in Figure 7.12.
Figure 7.12: Example of the iRODS subfolder structure containing the results of the jobs.
A given job can be selected by double-clicking on the relative folder and, navigating the subdirectories, you can access all the same input and output files of each job that have been described in the above sections.
It is very important that in order to visualise or download any output or input data from the portal, both via the ‘Results’ tab or the ‘iRODS’ tab, you always need to firstly log in into the ‘iRODS’ panel (Figure 7.11) because the storage database is accessible only to authenticated users.


What's the deal with Ruby Loops?
Well I've been looping around in Ruby for a bit now and to be honest it's getting a lil loopy... Okay, sorry for that one, but I had to put some bad humor in the blog. Anyway, there are three main loops in Ruby.
These loops are:
- While
- Until
- For
While:
While will execute a block of code in Ruby until the condition is not true at which point the code at the end will execute. This is the most straightforward of all of the loops. Honestly, while is my go to loop in Ruby. In terms of the syntax, it's fairly straight forward. You can check out the syntax for While and the other loop types here
Until:
Unless will excute a block of code so long as the condition is false. Once it is true, then the code at the end will execute. To be honest, I rarely use unless as I find it more taxing to think on the negative side of a statement. I realize that until helps with readability of code when it makes more sense to write a negative statement. It's definitely something that I'll have to work on over the course of DBC.
For:
For is the "workhorse" of looping in Javascript. However, I've found that in Ruby, it's rare that you want to use the For loop. Often times, it introduces additional code that is not helpful in the form of a needless itterator and if you need to itterate, then it's best to use .each in most situations... So moving forward, I'm retiring For in Ruby. It's going to be While or Until for me.


Raya and the Last Dragon
Long ago, in the fantasy world of Kumandra, humans and dragons lived together in harmony.
However, when sinister monsters known as the Druun threatened the land, the dragons
sacrificed themselves to save humanity. Now, 500 years later, those same monsters have
returned, and it's up to a lone warrior to track down the last dragon and stop the Druun for
good.


Marenthyu's Guide to Custom Firmware using SeedMiner
Getting your Game patched
Congratulations on acquiring your movable.sed and dsiware.bin!
You will now patch your game to allow for the core exploit to be executed, which will allow you to install
CFW.
Hold both files ready, you will need them in a moment.
 Go back to the beginning.
Section One - Using the DIS
Luckily for you, someone recently made a Service to make the next step a lot easier and possible without someone
else sharing their private files with you.
This service is the DSiWare
Injection Service, which we will now use to patch your game.
If the website is down for whatever
reason, you are still be able to continue by using TADPole or
Jason's Seedplanter to patch the game yourself.
After that you can continue with Section Three below.
- Open this website
- Click
Build with Parameters
on the left side - Enter your name in the Username Field - Any name will work, just dont make it too short or include spaces.
- Select the region you purchased your DSiWare Game in
- Upload the .bin file you previously got and saved to your Desktop in the
DsiBin
field - Upload your
movable.sed
in theMovableSed
field - Click Build
- Wait a few seconds
- Click the new Build that popped up on the left side. You should see a file downloadable with your name at the end
- Download this file
- Rename it by removing the
.patched_yourname
part, so it ends in .bin - for example, it should be named4B513956.bin
now
Section Two - Re-Import the Game
You should now have a fully patched .bin file - great!
We will now Re-Import the game to your 3DS's System Memory.
- Power off your 3DS if you haven't already
- Put your SD Card into your PC
- Open the SD Card's Contents
- Open the Folder Named
Nintendo 3DS
- Open the Folder Named like your ID0
- Open its sub-folder, it has a 32-character-long name again
- Open the Folder Named
Nintendo DSiWare
- Copy the patched .bin file you downloaded and renamed into this folder, overwriting the file that is already there.
- Put the SD Card back into your 3DS
- Start your 3DS
- Open System Settings
- Open Data Management (Green option in the bottom right)
- Open DSi Ware
- Tap SD Card
- Tap Your Game
- Tap Copy
- you will be asked if you want to override the already existing copy - Tap Yes
- Wait for it to copy
- Exist System Settings
- Start your Game.
You should be greeted by a white screen complaining that it could not load a file.(or solid light-green screens, top and bottom, with no text at all). This is the intended result.
NOTE: if you used SUDOKU, you may need to tap the touchscreen so the Game loads the modified save fileIf the game boots up normally, you have done something wrong. Redo the process from Section One on this page.
Section Three - Preparing your SD Card
We now have an entry-point Exploit. Awesome! We will now start downloading some things to install a few tools and the actual Custom Firmware.
- Download the latest Version of Luma3DS (Currently 9.0)
- Download the latest Version of this fork of b9sTool
(boot.nds)
- Download the latest Version of Boot9Strap (NOT the devkit, NOT the ntr version.)
- Download the latest Version of the Homebrew Menu
- Copy the
boot.firm
from the Luma3DS 7z archive to the root of your SD Card - Copy the
boot.3dsx
(Homebrew Menu) to the root of your SD Card - Copy the
boot.nds
from b9stool to the root of your SD Card - Copy the
boot9strap.firm
from theboot9strap.zip
file to the/boot9strap/
folder on your SD Card. (Create it if it does not exist)
Otherwise continue with Section VI here.


The Content-Location header indicates an alternate location for the returned data. The principal use is to indicate the URL of a resource transmitted as the result of content negotiation. Content-Location indicates the direct URL to use to access the resource, without further content negotiation in the future. The response contains the header with a link which should be discovered by security crawlers.


The GUTimeWrapper grabs sentences and lexical items from the TarsqiDocument and creates the input needed by components/gutime/TimeTag.pl, which is the wrapper around TempEx.pm in the same directory. The input required by TimeTag.pl is a file with content as follows:
<DOC> <DATE>20160102</DATE> <s> <lex id="l1" begin="1" end="5" pos="NNP">Fido</lex> <lex id="l2" begin="6" end="11" pos="NNS">barks</lex> <lex id="l3" begin="12" end="14" pos="IN">on</lex> <lex id="l4" begin="15" end="21" pos="NNP">Monday</lex> <lex id="l5" begin="21" end="22" pos=".">.</lex> </s> </DOC>
The DOC root and the DATE tag are required, the latter being the way that the DCT is handed to GUTime. Otherwise, only s and lex tags are allowed. GUTime does not require the lex tags to have the begin and end attributes, but it is okay for them to be there. Any kind of spacing between the tags is allowed. The wrapper creates the above text and then uses the Python subprocess module to run the Perl script, piping in the text. The output is exactly like the input except that TIMEX3 tags are added:
<DOC> <DATE><TIMEX3 VAL="20160102">20160102</TIMEX3></DATE> <s> <lex id="l1" begin="1" end="5" pos="NNP">Fido</lex> <lex id="l2" begin="6" end="11" pos="NNS">barks</lex> <lex id="l3" begin="12" end="14" pos="IN">on</lex> <TIMEX3 tid="t1" TYPE="DATE"><lex id="l4" begin="15" end="21" pos="NNP">Monday</lex></TIMEX3> <lex id="l5" begin="21" end="22" pos=".">.</lex> </s> </DOC>
Similar to what happened with the preprocessor results, the new TIMEX3 tags are exported to the tags TagRepository on the TarsqiDocument. One difference is that the GUTimeWrapper adds tags using the add_tag method on TagRepository, which also adds the tag to the opening_tags and closing tags dictionaries, so a separate invocation of index() is not needed.


Guidance
This data provides the section 251 amounts as reported by local authorities.
MS Excel Spreadsheet , 1.26MB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Excel Spreadsheet , 435KB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
MS Excel Spreadsheet , 3.32MB
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
Local authorities (LAs) are required, under section 251 of the Apprenticeships, Skills, Children and Learning Act 2009, to prepare and submit annually to the Secretary of State separate budget and outturn statements about their planned and actual expenditure for their education and children’s social care functions.
Section 251 replaces section 52 of the School Standards and Framework Act 1998 in England. Section 52 still applies in Wales.
The statements are the primary means of informing schools and the public in general about LA funding and expenditure plans. They are intended to give detailed information on each LAs planned expenditure on their education and children’s social care functions in a form that allows benchmarking, by schools forums and authorities.
Contact details:
Marcia Richards
Email<EMAIL_ADDRESS>Faustina Yeboah-Ofori
Email<EMAIL_ADDRESS>Sivadas Menon
Published: 13 December 2013
From: Department for Education
Part of: Section 251 documents


characters
writing/script
costume
set(apartment,school,bar)
emotion(romance,friendship,family)
Leonard Hofstadter
experimental physicist
works in Caltech
Although Leonard feels at home with his geek colleagues, he wants to be more social. Among the main characters, he generally has the least amount of difficulty interacting with ”non-geek” individuals.
Sheldon Cooper
theoretical physicist
Works in Caltech
Sheldon is logical and has an overly extensive general knowledge. He possesses an eidetic memory and an IQ of 187
Penny
waitress
Works in local Cheesecake Factory
Penny has an aspirations of becoming an actress. She is not particularly intellectually gifted or savvy in a specific technical field, but she has great social skills and is very knowledgeable about pop culture.
Howard Wolowitz
an aerospace engineer
Works in Caltech’s Department of Applied Physics
He has shown limited success with other women. Eventually, he found his girlfriend, Bernadette , An amateur microbiologist.
Rajesh Koothrappali
astrophysicist
Works in Caltech
He is very shy around women and is physically unable to talk to them unless he drinks alcohol. However, he has had much better luck with women as opposed to his overly confident best friend Howard.
an experienced writer
Chuck Lorre
works:
techonical director
David Saltzberg
a Professor of Physics and Astronomy at the University of California, Los Angeles.
live audience
sheldon's costume
comic book store
live store
labs
details to arouse resonance
apartment
details to makde it a real scientists' home


@Play.current.configuration.getString("application.version") Copyright ©
2014 Gregory Kopff. All Rights Reserved.
@** * Renders the 'scaffolding' that wraps the proper content of each page. * @param title The page title. * @param content The content this scaffolding wraps. *@ @(title: String)(content: Html) @import play.api.Play


| Package | Description |
|---|---|
| com.cyc.base.cycobject |
Interfaces for representations of Knowledge Base objects such as constants, functional expressions, lists, rules and assertions; this code is not supported for external developers.
|
| com.cyc.base.kbtool |
Interfaces for common operations for KB content, such as assertion, querying, etc; this code is not supported for external developers.
|
| com.cyc.baseclient |
Reference implementation of the Base Client API; this code is not supported for external developers.
|
| com.cyc.baseclient.cycobject |
Provides the attributes and behavior of Base Client API Knowledge Base objects such as
constants, functional expressions, lists, rules and assertions; this code is not supported for external developers.
|
| com.cyc.baseclient.kbtool |
Classes which wrap common operations for KB content, such as assertion, querying, etc; this code is not supported for external developers.
|
| Modifier and Type | Method and Description |
|---|---|
Guid |
CycConstant.getGuid()
Gets the guid
|
| Modifier and Type | Method and Description |
|---|---|
void |
CycConstant.setGuid(Guid newGuid)
Sets the guid
|
| Modifier and Type | Method and Description |
|---|---|
Guid |
LookupTool.getConstantGuid(String constantName)
Gets the Guid for the given constant name, raising an exception if the constant does not
exist.
|
| Modifier and Type | Method and Description |
|---|---|
CycConstant |
LookupTool.getConstantByGuid(Guid guid)
Gets a CycConstant by using its GUID.
|
String |
LookupTool.getConstantName(Guid guid)
Gets the name for the given constant guid.
|
CycConstant |
LookupTool.getKnownConstantByGuid(Guid guid)
Gets a known CycConstant by using its GUID.
|
CycConstant |
ObjectTool.makeConstantWithGuidName(Guid guid,
String constantName)
Makes a known CycConstant by using its GUID and name, adding it to the cache.
|
| Modifier and Type | Method and Description |
|---|---|
static CycConstantImpl |
CycObjectFactory.getCycConstantCacheByGuid(Guid guid)
Retrieves the CycConstantImpl with guid, returning null if not found in the cache.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GuidImpl
Provides the behavior and attributes of a Base Client GUID (Globally Unique
IDentifier).
|
| Modifier and Type | Method and Description |
|---|---|
static GuidImpl |
GuidImpl.fromGuid(Guid guid) |
void |
CycConstantImpl.setGuid(Guid newGuid)
Sets the guid
|
| Constructor and Description |
|---|
CycConstantImpl(String name,
Guid guid)
Constructs a new CycConstant object from name, guid and id.
|
| Modifier and Type | Method and Description |
|---|---|
Guid |
LookupToolImpl.getConstantGuid(String constantName) |
| Modifier and Type | Method and Description |
|---|---|
CycConstantImpl |
LookupToolImpl.getConstantByGuid(Guid guid) |
String |
LookupToolImpl.getConstantName(Guid guid) |
CycConstantImpl |
LookupToolImpl.getKnownConstantByGuid(Guid guid) |
CycConstantImpl |
ObjectToolImpl.makeConstantWithGuidName(Guid guid,
String constantName) |
Copyright © 2013–2018 Cycorp, Inc. All rights reserved.


Thiruananthapuram, the jewel in the emerald necklace that Kerala is for the Indian sub-continent, must surely have Parasuramanbeen a “must see” destination for ages, long before National Geographic Traveller classified it as one. Surely long before Sage Parasurama , according to local legend, threw his divine battle axe from Kanyakumari to Gokarnam to west Kerala, God’s own land, from the Varuna the sea god; before the times of Mahabali the democratic and just ruler of this wonderful land who was sent down to the netherworld through deceit. It doesnt take any flights of fancy to imagine that this land fired the imaginations of intrepid travellers and explorers like Columbus, Vasco da Gama, Marco Polo, Fa Hien, and quite possibly, countless others from the pages of history, recorded or not.


Precalculated item is designed to calculate result from given data by formula you entered. So if you have data like product prices and you want to calculate average value or to calculate discounts in percents or any other mathematic formula combined with some of our rules.
To create Precalculated item, select it from object tool bar and place it on page inside desire container (Static or Dynamic balloon) like shown in picture below.
To set specific properties for Precalculated balloon, select it in page like shown in picture below.
Specific properties for precalculated item are:
ForeColor, is color of the text.
Font, is font name and size use to draw text.
Text, is displayed when Formula doesn't exists.
Formula, mathematic formula combined with our specific rules. Consult example below.
Formula example:
Formula is combination of predefined functions for getting data and calculate it, and standard mathematic symbols.
Predefined functions are:
AVG(DataStream.Column), count average value from given DataStream and Column .
SUM(DataStream.Column), sums values from given DataStream and Column.
MIN(DataStream.Column), represents minimum value from given DataStream and Column .
MAX(DataStrem.Column), represents maximum value from given DataStream and Column.
DECTOBIN(DataStream.Column), will sum all data from DataStream and Column, and result will be in binary format.
DECTOHEX(DataStream.Column), will sum all data from DataStream and Column, and result will be in hex format.
Standard mathematic symbols are:
( ) + - * /<PHONE_NUMBER>
Some examples of finished formulas:
SUM(Product.Price) - sum all prices
( SUM(Product.Price) + 100 ) * 0.2 - sum all prices adds 100 and counts 20% off result.
Important: Do not place text that do not apply this rules, that formula will be bad and wont return anything as a result.