- authors
- Jason Lowe-Power
MSI Directory implementation
Implementing a directory controller is very similar to the L1 cache
controller, except using a different state machine table. The state
machine fore the directory can be found in Table 8.2 in Sorin et al.
Since things are mostly similar to the L1 cache, this section mostly
just discusses a few more SLICC details and a few differences between
directory controllers and cache controllers. Let’s dive straight in and
start modifying a new file MSI-dir.sm
.
``` {.sourceCode .c++} machine(MachineType:Directory, “Directory protocol”) : DirectoryMemory * directory; Cycles toMemLatency := 1;
MessageBuffer *forwardToCache, network=”To”, virtual_network=”1”, vnet_type=”forward”; MessageBuffer *responseToCache, network=”To”, virtual_network=”2”, vnet_type=”response”;
MessageBuffer *requestFromCache, network=”From”, virtual_network=”0”, vnet_type=”request”;
MessageBuffer *responseFromCache, network=”From”, virtual_network=”2”, vnet_type=”response”;
MessageBuffer *responseFromMemory;
{ . . . }
First, there are two parameter to this directory controller,
`DirectoryMemory` and a `toMemLatency`. The `DirectoryMemory` is a
little weird. It is allocated at initialization time such that it can
cover *all* of physical memory, like a complete directory *not a
directory cache*. I.e., there are pointers in the `DirectoryMemory`
object for every 64-byte block in physical memory. However, the actual
entries (as defined below) are lazily created via `getDirEntry()`. We'll
see more details about `DirectoryMemory` below.
Next, is the `toMemLatency` parameter. This will be used in the
`enqueue` function when enqueuing requests to model the directory
latency. We didn't use a parameter for this in the L1 cache, but it is
simple to make the controller latency parameterized. This parameter
defaults to 1 cycle. It is not required to set a default here. The
default is propagated to the generated SimObject description file as the
default to the SimObject parameter.
Next, we have the message buffers for the directory. Importantly, *these
need to have the same virtual network numbers* as the message buffers in
the L1 cache. These virtual network numbers are how the Ruby network
directs messages between controllers.
There is also one more special message buffer: `responseFromMemory`.
 The `responseFromMemory`
buffer will deliver response sent across the the memory port, as we will
see below in the action section.
After the parameters and message buffers, we need to declare all of the
states, events, and other local structures.
``` {.sourceCode .c++}
state_declaration(State, desc="Directory states",
default="Directory_State_I") {
// Stable states.
// NOTE: These are "cache-centric" states like in Sorin et al.
// However, The access permissions are memory-centric.
I, AccessPermission:Read_Write, desc="Invalid in the caches.";
S, AccessPermission:Read_Only, desc="At least one cache has the blk";
M, AccessPermission:Invalid, desc="A cache has the block in M";
// Transient states
S_D, AccessPermission:Busy, desc="Moving to S, but need data";
// Waiting for data from memory
S_m, AccessPermission:Read_Write, desc="In S waiting for mem";
M_m, AccessPermission:Read_Write, desc="Moving to M waiting for mem";
// Waiting for write-ack from memory
MI_m, AccessPermission:Busy, desc="Moving to I waiting for ack";
SS_m, AccessPermission:Busy, desc="Moving to I waiting for ack";
}
enumeration(Event, desc="Directory events") {
// Data requests from the cache
GetS, desc="Request for read-only data from cache";
GetM, desc="Request for read-write data from cache";
// Writeback requests from the cache
PutSNotLast, desc="PutS and the block has other sharers";
PutSLast, desc="PutS and the block has no other sharers";
PutMOwner, desc="Dirty data writeback from the owner";
PutMNonOwner, desc="Dirty data writeback from non-owner";
// Cache responses
Data, desc="Response to fwd request with data";
// From Memory
MemData, desc="Data from memory";
MemAck, desc="Ack from memory that write is complete";
}
structure(Entry, desc="...", interface="AbstractEntry") {
State DirState, desc="Directory state";
NetDest Sharers, desc="Sharers for this block";
NetDest Owner, desc="Owner of this block";
}
In the state_declaration
we define a default. For many things in SLICC
you can specify a default. However, this default must use the C++ name
(mangled SLICC name). For the state below you have to use the controller
name and the name we use for states. In this case, since the name of the
machine is “Directory” the name for “I” is “Directory”+”State” (for the
name of the structure)+”I”.
Note that the permissions in the directory are “memory-centric”. Whereas, all of the states are cache centric as in Sorin et al.
In the Entry
definition for the directory, we use a NetDest for both
the sharers and the owner. This makes sense for the sharers, since we
want a full bitvector for all L1 caches that may be sharing the block.
The reason we also use a NetDest
for the owner is to simply copy the
structure into the message we send as a response as shown below.
In this implementation, we use a few more transient states than in Table 8.2 in Sorin et al. to deal with the fact that the memory latency in unknown. In Sorin et al., the authors assume that the directory state and memory data is stored together in main-memory to simplify the protocol. Similarly, we also include new actions: the responses from memory.
Next, we have the functions that need to overridden and declared. The
function getDirectoryEntry
either returns the valid directory entry,
or, if it hasn’t been allocated yet, this allocates the entry.
Implementing it this way may save some host memory since this is lazily
populated.
``` {.sourceCode .c++} Tick clockEdge();
Entry getDirectoryEntry(Addr addr), return_by_pointer = “yes” { Entry dir_entry := static_cast(Entry, “pointer”, directory[addr]); if (is_invalid(dir_entry)) { // This first time we see this address allocate an entry for it. dir_entry := static_cast(Entry, “pointer”, directory.allocate(addr, new Entry)); } return dir_entry; }
State getState(Addr addr) { if (directory.isPresent(addr)) { return getDirectoryEntry(addr).DirState; } else { return State:I; } }
void setState(Addr addr, State state) { if (directory.isPresent(addr)) { if (state == State:M) { DPRINTF(RubySlicc, “Owner %s\n”, getDirectoryEntry(addr).Owner); assert(getDirectoryEntry(addr).Owner.count() == 1); assert(getDirectoryEntry(addr).Sharers.count() == 0); } getDirectoryEntry(addr).DirState := state; if (state == State:I) { assert(getDirectoryEntry(addr).Owner.count() == 0); assert(getDirectoryEntry(addr).Sharers.count() == 0); } } }
AccessPermission getAccessPermission(Addr addr) { if (directory.isPresent(addr)) { Entry e := getDirectoryEntry(addr); return Directory_State_to_permission(e.DirState); } else { return AccessPermission:NotPresent; } } void setAccessPermission(Addr addr, State state) { if (directory.isPresent(addr)) { Entry e := getDirectoryEntry(addr); e.changePermission(Directory_State_to_permission(state)); } }
void functionalRead(Addr addr, Packet *pkt) { functionalMemoryRead(pkt); }
int functionalWrite(Addr addr, Packet *pkt) { if (functionalMemoryWrite(pkt)) { return 1; } else { return 0; }
Next, we need to implement the ports for the cache. First we specify the
`out_port` and then the `in_port` code blocks. The only difference
between the `in_port` in the directory and in the L1 cache is that the
directory does not have a TBE or cache entry. Thus, we do not pass
either into the `trigger` function.
``` {.sourceCode .c++}
out_port(forward_out, RequestMsg, forwardToCache);
out_port(response_out, ResponseMsg, responseToCache);
in_port(memQueue_in, MemoryMsg, responseFromMemory) {
if (memQueue_in.isReady(clockEdge())) {
peek(memQueue_in, MemoryMsg) {
if (in_msg.Type == MemoryRequestType:MEMORY_READ) {
trigger(Event:MemData, in_msg.addr);
} else if (in_msg.Type == MemoryRequestType:MEMORY_WB) {
trigger(Event:MemAck, in_msg.addr);
} else {
error("Invalid message");
}
}
}
}
in_port(response_in, ResponseMsg, responseFromCache) {
if (response_in.isReady(clockEdge())) {
peek(response_in, ResponseMsg) {
if (in_msg.Type == CoherenceResponseType:Data) {
trigger(Event:Data, in_msg.addr);
} else {
error("Unexpected message type.");
}
}
}
}
in_port(request_in, RequestMsg, requestFromCache) {
if (request_in.isReady(clockEdge())) {
peek(request_in, RequestMsg) {
Entry e := getDirectoryEntry(in_msg.addr);
if (in_msg.Type == CoherenceRequestType:GetS) {
trigger(Event:GetS, in_msg.addr);
} else if (in_msg.Type == CoherenceRequestType:GetM) {
trigger(Event:GetM, in_msg.addr);
} else if (in_msg.Type == CoherenceRequestType:PutS) {
assert(is_valid(e));
// If there is only a single sharer (i.e., the requestor)
if (e.Sharers.count() == 1) {
assert(e.Sharers.isElement(in_msg.Requestor));
trigger(Event:PutSLast, in_msg.addr);
} else {
trigger(Event:PutSNotLast, in_msg.addr);
}
} else if (in_msg.Type == CoherenceRequestType:PutM) {
assert(is_valid(e));
if (e.Owner.isElement(in_msg.Requestor)) {
trigger(Event:PutMOwner, in_msg.addr);
} else {
trigger(Event:PutMNonOwner, in_msg.addr);
}
} else {
error("Unexpected message type.");
}
}
}
}
The next part of the state machine file is the actions. First, we define
actions for queuing memory reads and writes. For this, we will use a
special function define in the AbstractController
: queueMemoryRead
.
This function takes an address and converts it to a gem5 request and
packet and sends it to across the port that is connected to this
controller. We will see how to connect this port in the
configuration section <MSI-config-section>. Note that we need two
different actions to send data to memory for both requests and responses
since there are two different message buffers (virtual networks) that
data might arrive on.
``` {.sourceCode .c++} action(sendMemRead, “r”, desc=”Send a memory read request”) { peek(request_in, RequestMsg) { queueMemoryRead(in_msg.Requestor, address, toMemLatency); } }
action(sendDataToMem, “w”, desc=”Write data to memory”) { peek(request_in, RequestMsg) { DPRINTF(RubySlicc, “Writing memory for %#x\n”, address); DPRINTF(RubySlicc, “Writing %s\n”, in_msg.DataBlk); queueMemoryWrite(in_msg.Requestor, address, toMemLatency, in_msg.DataBlk); } }
action(sendRespDataToMem, “rw”, desc=”Write data to memory from resp”) { peek(response_in, ResponseMsg) { DPRINTF(RubySlicc, “Writing memory for %#x\n”, address); DPRINTF(RubySlicc, “Writing %s\n”, in_msg.DataBlk); queueMemoryWrite(in_msg.Sender, address, toMemLatency, in_msg.DataBlk); } }
In this code, we also see the last way to add debug information to SLICC
protocols: `DPRINTF`. This is exactly the same as a `DPRINTF` in gem5,
except in SLICC only the `RubySlicc` debug flag is available.
Next, we specify actions to update the sharers and owner of a particular
block.
``` {.sourceCode .c++}
action(addReqToSharers, "aS", desc="Add requestor to sharer list") {
peek(request_in, RequestMsg) {
getDirectoryEntry(address).Sharers.add(in_msg.Requestor);
}
}
action(setOwner, "sO", desc="Set the owner") {
peek(request_in, RequestMsg) {
getDirectoryEntry(address).Owner.add(in_msg.Requestor);
}
}
action(addOwnerToSharers, "oS", desc="Add the owner to sharers") {
Entry e := getDirectoryEntry(address);
assert(e.Owner.count() == 1);
e.Sharers.addNetDest(e.Owner);
}
action(removeReqFromSharers, "rS", desc="Remove requestor from sharers") {
peek(request_in, RequestMsg) {
getDirectoryEntry(address).Sharers.remove(in_msg.Requestor);
}
}
action(clearSharers, "cS", desc="Clear the sharer list") {
getDirectoryEntry(address).Sharers.clear();
}
action(clearOwner, "cO", desc="Clear the owner") {
getDirectoryEntry(address).Owner.clear();
}
The next set of actions send invalidates and forward requests to caches that the directory cannot deal with alone.
``` {.sourceCode .c++} action(sendInvToSharers, “i”, desc=”Send invalidate to all sharers”) { peek(request_in, RequestMsg) { enqueue(forward_out, RequestMsg, 1) { out_msg.addr := address; out_msg.Type := CoherenceRequestType:Inv; out_msg.Requestor := in_msg.Requestor; out_msg.Destination := getDirectoryEntry(address).Sharers; out_msg.MessageSize := MessageSizeType:Control; } } }
action(sendFwdGetS, “fS”, desc=”Send forward getS to owner”) { assert(getDirectoryEntry(address).Owner.count() == 1); peek(request_in, RequestMsg) { enqueue(forward_out, RequestMsg, 1) { out_msg.addr := address; out_msg.Type := CoherenceRequestType:GetS; out_msg.Requestor := in_msg.Requestor; out_msg.Destination := getDirectoryEntry(address).Owner; out_msg.MessageSize := MessageSizeType:Control; } } }
action(sendFwdGetM, “fM”, desc=”Send forward getM to owner”) { assert(getDirectoryEntry(address).Owner.count() == 1); peek(request_in, RequestMsg) { enqueue(forward_out, RequestMsg, 1) { out_msg.addr := address; out_msg.Type := CoherenceRequestType:GetM; out_msg.Requestor := in_msg.Requestor; out_msg.Destination := getDirectoryEntry(address).Owner; out_msg.MessageSize := MessageSizeType:Control; } } }
Now we have responses from the directory. Here we are peeking into the
special buffer `responseFromMemory`. You can find the definition of
`MemoryMsg` in `src/mem/protocol/RubySlicc_MemControl.sm`.
``` {.sourceCode .c++}
action(sendDataToReq, "d", desc="Send data from memory to requestor. May need to send sharer number, too") {
peek(memQueue_in, MemoryMsg) {
enqueue(response_out, ResponseMsg, 1) {
out_msg.addr := address;
out_msg.Type := CoherenceResponseType:Data;
out_msg.Sender := machineID;
out_msg.Destination.add(in_msg.OriginalRequestorMachId);
out_msg.DataBlk := in_msg.DataBlk;
out_msg.MessageSize := MessageSizeType:Data;
Entry e := getDirectoryEntry(address);
// Only need to include acks if we are the owner.
if (e.Owner.isElement(in_msg.OriginalRequestorMachId)) {
out_msg.Acks := e.Sharers.count();
} else {
out_msg.Acks := 0;
}
assert(out_msg.Acks >= 0);
}
}
}
action(sendPutAck, "a", desc="Send the put ack") {
peek(request_in, RequestMsg) {
enqueue(forward_out, RequestMsg, 1) {
out_msg.addr := address;
out_msg.Type := CoherenceRequestType:PutAck;
out_msg.Requestor := machineID;
out_msg.Destination.add(in_msg.Requestor);
out_msg.MessageSize := MessageSizeType:Control;
}
}
}
Then, we have the queue management and stall actions.
``` {.sourceCode .c++} action(popResponseQueue, “pR”, desc=”Pop the response queue”) { response_in.dequeue(clockEdge()); }
action(popRequestQueue, “pQ”, desc=”Pop the request queue”) { request_in.dequeue(clockEdge()); }
action(popMemQueue, “pM”, desc=”Pop the memory queue”) { memQueue_in.dequeue(clockEdge()); }
action(stall, “z”, desc=”Stall the incoming request”) { // Do nothing. }
Finally, we have the transition section of the state machine file. These
mostly come from Table 8.2 in Sorin et al., but there are some extra
transitions to deal with the unknown memory latency.
``` {.sourceCode .c++}
transition({I, S}, GetS, S_m) {
sendMemRead;
addReqToSharers;
popRequestQueue;
}
transition(I, {PutSNotLast, PutSLast, PutMNonOwner}) {
sendPutAck;
popRequestQueue;
}
transition(S_m, MemData, S) {
sendDataToReq;
popMemQueue;
}
transition(I, GetM, M_m) {
sendMemRead;
setOwner;
popRequestQueue;
}
transition(M_m, MemData, M) {
sendDataToReq;
clearSharers; // NOTE: This isn't *required* in some cases.
popMemQueue;
}
transition(S, GetM, M_m) {
sendMemRead;
removeReqFromSharers;
sendInvToSharers;
setOwner;
popRequestQueue;
}
transition({S, S_D, SS_m, S_m}, {PutSNotLast, PutMNonOwner}) {
removeReqFromSharers;
sendPutAck;
popRequestQueue;
}
transition(S, PutSLast, I) {
removeReqFromSharers;
sendPutAck;
popRequestQueue;
}
transition(M, GetS, S_D) {
sendFwdGetS;
addReqToSharers;
addOwnerToSharers;
clearOwner;
popRequestQueue;
}
transition(M, GetM) {
sendFwdGetM;
clearOwner;
setOwner;
popRequestQueue;
}
transition({M, M_m, MI_m}, {PutSNotLast, PutSLast, PutMNonOwner}) {
sendPutAck;
popRequestQueue;
}
transition(M, PutMOwner, MI_m) {
sendDataToMem;
clearOwner;
sendPutAck;
popRequestQueue;
}
transition(MI_m, MemAck, I) {
popMemQueue;
}
transition(S_D, {GetS, GetM}) {
stall;
}
transition(S_D, PutSLast) {
removeReqFromSharers;
sendPutAck;
popRequestQueue;
}
transition(S_D, Data, SS_m) {
sendRespDataToMem;
popResponseQueue;
}
transition(SS_m, MemAck, S) {
popMemQueue;
}
// If we get another request for a block that's waiting on memory,
// stall that request.
transition({MI_m, SS_m, S_m, M_m}, {GetS, GetM}) {
stall;
}
You can download the complete MSI-dir.sm
file
here <../../_static/scripts/part3/MSI_protocol/MSI-dir.sm>.


Welcome to the World of Open Chatrooms !!!!
Join a chat
Username
Room name
Join
Designed by
@AkashTheGreat
with


As it turns out, people are often interested in learning more about my site's design and structure. I occasionally receive correspondence from other programmers and students asking me how I built it, what makes it tick, etc. I decided it was time to write everything down in one place so that I can simply link to it the next time somebody asks.
To make this fun, let's sort-of pretend I'm actually responding to someone who happens to chat in a very structured way like a magazine interview after it has gone through the editing process.
P.S. No, I don't find any of your messages annoying. It's very flattering. :)
I really like what you've done with your site. What did you use to make it? Is it WordPress? You see, I'm interested in making my own website and I hear WordPress is great for...
Nope!
My website is built using Jekyll, a really fun and mature open-source static site generator written in Ruby.
What does that mean?
Think of Jekyll as a CMS, like WordPress, but it's not hosted anywhere in the cloud. Instead, it's a program you run on your computer that reads in a directory structure laid out in a mostly opinionated manner, then processes all your content (blog posts, pages, images, other static assets such as CSS) and renders it all into a static set of files and folders that you can then shove into a server and host like any other static site.
Wow, that seems like a ton of work to run a website and blog. Do you copy all these files over manually each time?
No, it's not too much work if you can use Git.
You see, GitHub Pages comes with native Jekyll support. This means that I create a repo out of a Jekyll-generated directory structure, and push to it whenever I want to update something. GitHub runs a build, and starts serving the latest version of the site within seconds.
It's pretty seamless once you get it set up.
Ah, that's convenient. So, is there a blogging UI of some sort?
No. Unfortunately, you will need to write and edit your posts directly, using a text editor.
In HTML!?
Oh no no! Fortunately, you can use Markdown (and other markup languages), which is the same language used to format text on a plethora of sites, such as Stack Exchange and Reddit.
Along with a ton of other features, Jekyll also comes with the Liquid Templating Engine pre-configured, so you can use templates and not have to copy-paste your site header across all your pages. It's pretty nice.
Okay, you're really selling me on this Jekyll thing.
But wait, there's more!
WordPress and other website/blog backend systems generate webpages on the fly as requested. This requires you to pay for server time to keep your site up and running. It's not super expensive, but GitHub Pages is FREE. All I pay for is my domain (annual, inexpensive, personally using Namecheap). This is optional, and you can host your site on a free GitHub subdomain (username.github.io) instead if you prefer.
And since Jekyll only builds the site once every time you update your content, pages are served in a snap.
So how did you go about designing your site? Is the code available somewhere?
Source code is available here.
I built this site back when using Jekyll themes meant cloning an empty repo from someone and adding your posts and pages to it. Now, it's possible to install themes via Ruby gems, apparently.
Anyways, I had only intended to make a blog. So I started off with the Poole theme by @mdo (of Bootstrap fame). You can see Poole's design influences on my blog, still. A year or so later, I decided to take down my old, static portfolio site and re-do the whole thing as a new, Frankenstein'd extension of my Jekyll blog. I peppered in a bunch of frameworks and made the monstrosity that this site is today. The code is as clean, readable and maintainable as can be, but digging into it for the first time may not be easy. Feel free to take inspiration from my design, folder layout etc.
Jekyll is highly opinionated, yet rather flexible in its own way; this is just my way of using it.


Vertexes Aim: To edit a meshes vertexes in Real-time
|
|
If you've already read the section on Meshes beforehand then hopefully you'll know most of what we will be doing already in this tutorial, if not - go away and read it first !.
let's recap:
So, armed with that info - you should know what makes a 3d object tick !.
Lets take a flat square as an example, it is made up of 4 vertexes and 2
triangles. What we are planning of doing is to take 2 of those vertexes and
change their coordinates.
Infact as mentioned in the Introduction to Meshes, we can even change the colour of the vertexes in realtime too. Run the example - what you can hopefully see is a square object (which is slowly spinning on the Z plane), being pulled out of shape in 2 corners - while every-so-often the colours change.
It's a very easy effect to create, I wont go into great detail about how/why the program works - but here's a quick rundown if your interested:
We setup the variable 'COUNTER', which does exactly that.. to be used as a counter. Every time the program runs through its main loop, it is incremented. Based on what value the counter is equal to, corresponds to what direction we should pull the vertexes. If the counter reaches 1000 then change the colour of each vertex to a random selection, before resetting the counter value.
Let's take a look:
| Graphics3D 800,600 SetBuffer BackBuffer() camera=CreateCamera() CameraViewport camera,0,0,800,600 light=CreateLight() plane=LoadMesh("plane.3ds") PositionEntity plane,0,0,25 EntityFX plane,2 surface=GetSurface(plane,CountSurfaces(plane)) VertexColor surface,0,255,0,0 VertexColor surface,1,0,255,0 VertexColor surface,2,0,0,255 VertexColor surface,3,255,0,255 While Not KeyHit(1) TurnEntity plane,0,0,.3 counter=counter+1 If counter<500 Then x1#=-.01 y1#=-.01 x2#=+.01 EndIf If counter>499 Then x1#=+.01 y1#=+.01 x2#=-.01 EndIf xx#=VertexX(surface,0) yy#=VertexY(surface,0) zz#=VertexZ(surface,0) VertexCoords surface,0,xx+x1,yy+y1,zz xx#=VertexX(surface,2) yy#=VertexY(surface,2) zz#=VertexZ(surface,2) VertexCoords surface,2,xx+x2,yy+y1,zz If counter=1000 Then counter=0 VertexColor surface,0,Rnd#(0,255),Rnd#(0,255),Rnd#(0,255) VertexColor surface,1,Rnd#(0,255),Rnd#(0,255),Rnd#(0,255) VertexColor surface,2,Rnd#(0,255),Rnd#(0,255),Rnd#(0,255) VertexColor surface,3,Rnd#(0,255),Rnd#(0,255),Rnd#(0,255) EndIf UpdateWorld RenderWorld Text 350,500,"Vertex Control" Flip Wend End |
So how do we get at the vertexes of the object ?
Well for starters we load the object with the LoadMesh command, the object we are loading is of course called Plane.3ds.
| EntityFX plane,2 |
Now here's a new command we haven't seen before !, this command is really more of mode switch than anything else. But setting values we can access the entity in different ways. the mode value '2' is to able vertex colouring on the whole entity, by default this is turned off.
Here's those mode settings:
|
1 = Full-Bright 2 = Use Vertex Colours 4 = Flatshading 8 = Disable Fog |
There is another command very similar to EntitiyFX called BRUSHFX. This uses the same mode settings, but instead of changing the whole entity will work on a single brush. (remember a mesh has surfaces, with brushes applied to them)
| surface=GetSurface(plane,CountSurfaces(plane)) |
In order to get at the vertexes we must first unlock them, we do this by creating a pointer variable that holds the memory address to the surfaces on the mesh.
Calm down !, we don't have to get our hands dirty calling with lots of nasty math's - instead we just use the GETSURFACE command, which likes us to pass firstly the mesh name - and secondly the amount of surfaces it has. As you can see I've cheated and used the COUNTSURFACES command to do this for me.
|
VertexColor surface,0,255,0,0 VertexColor surface,1,0,255,0 VertexColor surface,2,0,0,255 VertexColor surface,3,255,0,255 |
Before going into the main loop, I've set the colour of each vertex to a different colour. This gives us a nice rainbow effect !. As you can see we pass the pointer variable SURFACE to the VERTEXCOLOR command, as well as the vertex number (0-3, since our object only has 4 points) - followed by the colour values for the Red, Green and Blue shades. (must be in the range of 0 (Dark) through to 255 (Light))
|
xx#=VertexX(surface,0) yy#=VertexY(surface,0) zz#=VertexZ(surface,0) |
Since I want the coordinates of the mesh to change all the time, I cant set it with a value that doesn't change. Every update I've got to get the current coordinates and slightly update them (by adding an offset to the X and Y coords).
I do this by firstly, getting the current X,Y and Z vertex coords - using the various get vertex commands.
VertexX(surface,0) - gives us access to the X coordinate of the object surface, at vertex 0.
Just as, VertexY(surface,99) - would give us access to the Y coodinate of vertex 99 !!!.
| VertexCoords surface,0,xx+x1,yy+y1,zz |
As you've probably worked out by now, this is the main instruction for changing the actual Vertex positions. It needs to be called with the Surface pointer value, followed by the new values for the X, Y and Z positions.
And that's all there is to it !!
But why would you want to change the coordinates ?
All games will alter their objects, its just a case of working out how, and where they do it. Imagine you've just written a driving simulation.. wouldn't it be nice when you crash the car to reflect the damage ?. Perhaps crumple that fender.. or crack that window.
Just like a certain other car game currently in the charts, they use exactly the same method. You gotta hand it to B3D - You want it.. it's there, now go and use it wisely !.
More Tutorials to follow..
Tutorials written by Paul Gerfen
(c) 2001GameCodingUK


Explore the workings of the Trove API
{{ error }}
{% endif %} {% if data %}
{{ data|safe }}
{% endif %}
Click on any of the examples below to open them in this console. If you want to use them in your own code you'll need to get an API key and add '&key=[Your API key]' to the url.
See the Trove API documentation for a full list of available parameters and detailed information on constructing queries.
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/result?q=wragge&zone=all |
|
https://api.trove.nla.gov.au/v2/result?q=wragge&zone=all&encoding=json&n=50 |
|
https://api.trove.nla.gov.au/v2/result?q=nuc:ANL&zone=all&encoding=json |
|
https://api.trove.nla.gov.au/v2/result?q=wragge&zone=all&encoding=json&l-australia=y&l-availability=y/f |
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/result?q=wragge+AND+weather&zone=newspaper&encoding=json |
|
https://api.trove.nla.gov.au/v2/result?q=wragge AND weather&zone=newspaper&encoding=json&l-year=1903 |
|
https://api.trove.nla.gov.au/v2/result?q=wragge AND weather&zone=newspaper&encoding=json&l-decade=190&facet=year&n=0 |
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/result?q=wragge AND weather&zone=book,picture&encoding=json |
|
https://api.trove.nla.gov.au/v2/result?q=weather&zone=book&encoding=json&l-format=Thesis |
|
https://api.trove.nla.gov.au/v2/result?q=weather&zone=book&encoding=json&facet=format&n=0 |
|
https://api.trove.nla.gov.au/v2/result?q=war memorials&zone=list&encoding=json |
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/newspaper/41697877?encoding=json&reclevel=full |
|
https://api.trove.nla.gov.au/v2/newspaper/41697877?reclevel=full&include=articletext |
|
https://api.trove.nla.gov.au/v2/work/36904481?encoding=json&reclevel=full |
|
https://api.trove.nla.gov.au/v2/work/34769014?encoding=json&include=workVersions,holdings&reclevel=full |
|
https://api.trove.nla.gov.au/v2/list/1442?encoding=json&reclevel=full&include=listItems |
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/newspaper/titles?state=vic |
|
https://api.trove.nla.gov.au/v2/newspaper/title/35?encoding=json |
|
https://api.trove.nla.gov.au/v2/newspaper/title/35?encoding=json&include=years |
| Parameters | url |
|---|---|
|
https://api.trove.nla.gov.au/v2/contributor?encoding=json |
|
https://api.trove.nla.gov.au/v2/contributor/ANL?encoding=json&reclevel=full |


Submit a solution, or see the Scoreboard.
{% if submissions_enabled %} For the second round, the submission deadline is Sunday, 12:00, and the winners will be announced at 13:00 at the Red Hat booth. {% else %} The second round deadline has been reached and further submissions have been disabled. The winners will be announced at 13:00 at the Red Hat booth. {% endif %}
Due to large numbers of invalid solutions, we decided to post a few examples with solutions so you can test your script before submitting.
| Die | Example solution |
|---|---|
| [1, 1, 3] | [2, 2, 1] |
| [1, 2, 3, 4, 5, 6] | No solution (return an empty string) |
| [2, 3, 4, 5, 6, 7] | [1, 1, 3, 7, 7, 8] |
| [3, 3, 3, 3, 6, 6] | [1, 1, 4, 4, 7, 7] |
| [1, 1, 1] | No solution (return an empty string) |
For this task, you're going to play a dice game, but first you must prepare for an overwhelming victory. The game itself is very simple.  (On a tie, both players must reroll until someone scores.)
These aren't standard dice however. Each player can put any positive number on any side of the die as long as the number of sides match and the total of all the chosen numbers are the same. For example, one player might use a six sided die with the numbers [3, 3, 3, 3, 6, 6] while the other player uses a six sided die with the numbers [4, 4, 4, 4, 4, 4]. The interesting part of this game is that even with the same number of sides and the same total, different dice have different chances of winning. Using the example die, the player with all 4's will win 2/3 of the time.
To prepare for this game, you're investigating different ways of picking the numbers. To do this, write a program that will take an opponent's die and output some die which will win against it more than half the time. If no die satisfies the task requirements, return an empty string.
Comma separated numbers representing opponent's die as a first command line argument of your program.
For example:
$ <your_program> 3,3,3,3,6,6
Print your solution to stdout
also as
comma separated values. If solution for given input
doesn't exist, print empty string.
Your submission will be scored in 3 categories: time, memory usage and tokens. Tokens represent the lenght of your script in meaningful units of code (i.e. making the variable and function names shorter won't help, but using less variables and functions will).
Your program will be tested by several performance tests judging it in terms of time and memory. Each test will be rerun several times and the values will be averaged.
Be warned that each test has to finish within 60 seconds on our testing laptop (Intel Core i7 with 4 cores, 12GB RAM, Fedora 27). If your program takes longer, it will be terminated and marked as timeouted.
{% if language == "python" %}
Python{% else %}Python{% endif %} |
{% if language == "c" %}
C{% else %}C{% endif %} |
{% if language == "java" %}
Java{% else %}Java{% endif %} |
Python 3.6
You must submit your solution in the form of Python source code. This source code must be placed in one and only one file with a name of your choosing.
Your solution must run using the following command, without any extra dependencies, accepting the opponent's die as the first command line argument:
$ python3 your_solution_file.py 1,2,3,4,5,6
Your solution must not print anything to the standard output, other than the final computation result.
{% elif language == "c" %}You're going to need an implementation clang. If you're using Linux, just install the package. If you're using Windows, go fish.
You must submit your solution in the form of C source code. This source code must be placed in one and only one file with a name of your choosing. Your solution must compile using the following command, without any extra dependencies:
$ clang YourSolutionFile.c -o solution
Your solution must include the standard C main method, that is a method with the following signature:
int main(int argc, char *argv[])
We will use this method as the entry point to your submitted solution, using a command such as this:
$ ./solution 1,2,3,4,5,6
Your solution must not print anything to the standard output, other than the final computation result.
{% elif language == "java" %}You're going to need an implementation of Java SE 9, preferably OpenJDK 9. If you're using Linux, just install the package. If you're using Windows, go fish.
You must submit your solution in the form of Java source code. This source code must be placed in one and only one file with a name of your choosing. Your solution must compile using the following command, without any extra dependencies:
$ javac YourSolutionFile.java
Your solution must include the standard Java main method, that is a method with the following signature:
public static void main(final String... args)
We will use this method as the entry point to your submitted solution, using a command such as this:
$ java YourSolutionFile 1,2,3,4,5,6
Your solution must not print anything to the standard output, other than the final computation result.
To run your code, we will be using the following JRE:
openjdk version "9.0.1"
OpenJDK Runtime Environment (build 9.0.1+11)
OpenJDK 64-Bit Server VM (build 9.0.1+11, mixed mode)
We will be limiting the memory allocation pool to 32 megabytes.
The final command we will use to run your submission will therefore be:
$ java -Xms32m -Xmx32m YourSolutionFile 1,2,3,4,5,6
We are aware of the fact that this JVM configuration may make several non-deterministic performance optimizations which may give unfair advantage to different solutions running in different JVM instances. To offset this, we will be executing each submission multiple times and the resulting score will be based on an average of the individual execution times.
{% endif %}


---
layout: collection-item
title: S3 Portfolio Clinic
enable-header: true
page-text: "S3 offers a monthly podcast where we explore and discuss best practices, professional advice, tips of the trade, and insight into multiple CG fields. In every session we invite our industry professional volunteers to answer all your questions on everything, from demo reels to resumes. Have a direct question about your work? Let us help you answer it by having your work featured in our discussions."
---
{{ page.page-text }}
{% assign events = site.events | reverse | where: "event-type", "portfolio-clinic" %}
{% for event in events %}
{% if event.enable-featured-banner == true %}
{% capture featured_title %}{{event.title}}{% endcapture %}
{% capture featured_text %}{{event.description}}{% endcapture %}
{% capture featured_class %}{{event.class}}{% endcapture %}
{% capture featured_image %}{{event.card-img-url}}{% endcapture %}
{% capture featured_url %}{{event.url}}{% endcapture %}
{% include featured-card.html featured_class=featured_class featured_image=featured_image featured_title=featured_title featured_text=featured_text featured_url=featured_url %}
{% endif %}
{% endfor %}


Facts about me:
- I like to code.
- I have one sister
- I was in the military
What I do for fun:
- Listen to music
- Code ;)
- VIDEO GAMES!
Education:
- Arlington High School
- Boise State University
- Code Fellows
Top 10 Favorite Video Games
- Pokemon
- Halo
- Smash Bros
- Kingdom Hearts
- Ultimate Ninja Storm
- Call of Duty
- GTA
- Sims
- Shenmue
- Mortal Kombat


When an Italian Public Administation develops or commissions software it must comply with the art. 69 of the Codice dell’Amministrazione Digitale which mandates to publish it in a public open repository covered with an open license in order to allow other administrations to reuse it.
Such a process is described in details in the Guidelines issued by the Agency for Digital Italy. The guidelines technical attachments are formulated to be directly included in contracts and specifications related to software development, software modification and maintenance, in order to fulfil the release obligation.
The process brief:
- The administration must always obtain full ownership of the software.
- The software must be published in a public repository (e.g., GitHub, GitLab, BitBucket etc., also on-premise installations providing that they are publicly accessible).
- The software must be covered by one of the licenses approved by the Open Source Initiative (the guidelines suggest some in particular, in order to allow maximum reusability).
- The repository must contain the file
publiccode.yml
which describes the software characteristics and allows to populate the Developers Italia catalogue.
publiccode.yml
Every public software repository must contain a file named publiccode.yml
containing all the information useful to populate the Developers Italia
catalogue. publiccode.yml is a standard originally created in
Italy but it is in the process of being adopted internationally.
publiccode.yml specifications Editor/validator
Catalogue publication
The catalogue publication, as well as the updates transposition, is automatic
since Developers Italia, through a crawler, will periodically find and import
all the repositories containing a publiccode.yml
file.
Please note: to allow the Developers Italia crawler to find its own repositories, each administration must register the code hosting account used to publish all its projects (e.g., the organization’s GitHub account). This is a one-off operation. See the guidelines for more information.
Rules of the software catalog Code hosting account registration form
Third party open source software
The third party open source software, such as those which are not put into reuse by the Public Administration but are potentially interesting for the public sector, can be included in the Developers Italia catalogue. As such, it is necessary to:
- fill and include a
publiccode.yml
file in the repository (leaving thecodiceIPA
key empty); - include the repository URL in the list by opening a pull request on GitHub.


CARTway
Sheo Shankar
<EMAIL_ADDRESS>Home
Shop Now
Fav Shop
Last Bills
Unpaid Bills
Log Out
About App
Privacy Policy
Terms of use
Upload Item List
Upload
Create Item List


Think you can sing Freddie Mercury vocals? Google AI will stop you now
Google has used machine learning for a variety of practical uses lately, ranging from live captions and transcriptions to image processing and more. Now, the company has a new use for the tech, as it’s able to rate your vocals in Queen songs.
The company announced its FreddieMeter AI experiment on its YouTube blog today, and it analyzes your voice with AI to determine how much of a match you are to late frontman Freddie Mercury.
Google says the AI — which was trained on Mercury’s vocals and people trying to sound like him — analyzes your pitch, timbre, and melody in order to generate a score out of 100. Fortunately, you can choose one of four Queen songs as part of the experiment, namely Bohemian Rhapsody, Don’t Stop Me Now, We Are The Champions, and Somebody to Love.
FreddieMeter uses on-device machine learning, so your voice sample isn’t being uploaded to the internet. This certainly helps give some peace of mind that your voice sample and associated data isn’t being mishandled.
FreddieMeter — created in support of the Mercury Phoenix Trust to fight HIV/Aids — can be accessed on Android, iPhones, and desktop devices. Check it out via the button below.


Home
Work
About Us
Register
Job Seeker
Recruiter
Sign In
Service
Contact US
Search
© 2014 VideoCV. All Rights Reserved.
We help you spent time wisely
Learn how it works
Get resumes with videos and save time as there is saying time is money
Learn how it works
Looking out for your dream job.Register with us
Job Seeker
Get a wide range of variety Resumes with videos / visuals
Job Recruiter
×
Close
Sign Up
Username/Email
Password
SIGN IN
Forgot your password?


{% extends "base.html" %} {% from "macros.html" import render_pill, render_assessment_status_pill %} {% block body %}
| Name | Client | Platform | Type | Language | Status | Creator | Actions | {% for assessment in assessments %}
|---|---|---|---|---|---|---|---|
| {{ assessment.name }} | {{ assessment.client.short_name }} | {{ assessment.platform }} | {{ render_pill(assessment.type, 'secondary') }} | {{ render_pill(assessment.lang, 'primary') }} | {{ render_assessment_status_pill(assessment.status) }} | {{ assessment.creator.name }} |


All-in-One Docker Compose Installation
The all-in-one Docker Compose installation is a quick, easy, packaged solution that requires few steps and should get all components up and running quickly. The downside is that this may not scale well, as everything is installed on one server. After a certain number of users (perhaps 50 or so), the server could become overloaded.
You can read about the different types of installation options on the developer introduction page.
Before you begin
You must have the following items installed and running:
- MongoDB Server: You can find instructions on installing MongoDB on the MongoDB website.
- RabbitMQ: You can find instructions on installing RabbitMQ on the RabbitMQ website.
You should also have the following resources on your machine before installing:
- Minimum CPU: 2.0 GHz
- Minimum RAM: 4GB
- Minimum disk space required: 4GB
Operating system requirements
On Mac, we support OS X El Capitan (10.11) or newer. If you are on an older OS, you may have to upgrade.
Install Docker Toolbox
If you do not already have Docker installed, do that first. You can install Docker Toolbox from the Docker Toolbox product page.
If you do have Docker installed, you’ll want to make sure that you have Docker Compose version 1.7 or later. You can check your version using the command docker-compose version
.
- On the server, you can install Docker with the following command:
sudo yum install docker
Get the source code
Clone the Proxy repository. This repository contains a number of setup files that you can edit, and will help you easily spin up a Docker container.
git clone https://github.com/coralproject/Proxy.git
Then cd into the Proxy directory.
cd Proxy
Set environment variables
The env.conf
file contains environment variables you need to set. Setting your environment variables tells Docker which IP address your Coral frontend will have, as well as other information such as your MongoDB username and password.
export FRONTEND_HOST=
export GAID_VALUE=xxxx
export AUTH_TOKEN_VALUE=xxxx
export RABBIT_USER=rabbitmq
export RABBIT_PASS=welcome
# mongo:
export MONGO_AUTHDB=admin
export MONGO_USER=coral-user
export MONGO_PASS=welcome
export MONGO_DB=coral
#elkhorn
export accessKeyId=xxx
export secretAccessKey=xxx
export pillarHost=xxx
export basicAuthorization=xxx
export bucket=xxx
export region=xxx
# sponge:
export STRATEGY_CONF=/usr/local/strategy.json
Required edits:
FRONTEND_HOST
: set to your desired IP address for the front end. For this example, we will use<IP_ADDRESS>
, which is the default Docker machine IP for local machine installs.
Optional edits:
GAID_VALUE=xxxx
: If you’re using Google Analytics, set your token atexport GAID_VALUE=xxxx
. Otherwise, delete or comment out this line.export AUTH_TOKEN_VALUE=xxxx
: If you’re using a custom auth token, set that atexport AUTH_TOKEN_VALUE=xxxx
. Otherwise, delete or comment out this line.
 Spin up the Docker container:
docker-compose -f docker-compose.yml up -d
The docker-compose.yml
file contained in the docker-setup directory contains all the instructions that Docker Compose needs to set up the Coral Ecosystem.
2. Note: If this is your first time spinning up the Docker container, Docker is going to download and install a number of Docker images first. These can be fairly large (~500MB per image), so it may take a few minutes.
3. Once all Docker images have been downloaded, you’ll see something like the following in your terminal:
Creating proxy_mongodata_1
Creating proxy_sponge_1
Creating proxy_rabbitmq_1
Creating proxy_atollapp_1
Creating proxy_xeniaapp_1
Creating proxy_pillarapp_1
Creating proxy_cayapp_1
Creating proxy_proxy_1
Note: If this is your first time spinning up the Docker container, be aware that there is a large chunk of dummy data being downloaded as well. This happens behind the scenes, so it isn’t as easy to tell whether or not it is done. You can check on its progress by looking at the logs.
First you have to find the container id for proxy_mongodata_1:
docker ps
Then use the container id to view the logs:
docker logs e0bbd7be19c7
If it has not finished downloading, you’ll see this as the final line in the logs:
Notice: doownloading dump from https://s3.amazonaws.com/coral-demo-dataset/dump.tar.gz
If it has finished downloading, you should see this among the final lines in the logs:
2016-07-21T00:42:33.024+0000 I NETWORK [HostnameCanonicalizationWorker] Starting hostname canonicalization worker
2016-07-21T00:42:33.025+0000 I FTDC [initandlisten] Initializing full-time diagnostic data capture with directory '/data/db/diagnostic.data'
2016-07-21T00:42:33.031+0000 I NETWORK [initandlisten] waiting for connections on port 27017
4.  This up-down-up sequence initializes authentication on MongoDB.
docker-compose -f docker-compose.yml down
5. Finally, start the Docker container back up. In future (now that the Docker images have all been downloaded and set up), you can simply use this command to start your Docker container.
docker-compose -f docker-compose.yml up -d
Test it out
To make sure it’s working, try to hit the front-end URL in your browser. This is the URL you specified as FRONTEND_HOST
in the env.conf
setup above; in this case, https://<IP_ADDRESS>.
Troubleshooting
Viewing running Docker containers
To see all of the Docker containers currently running, use the command docker ps
(you can read more about this command and its options at the Docker website).
docker ps
You should have all of the following containers running:
- nginx:stable-alpine
- coralproject/cay
- coralproject/elkhorn
- coralproject/pillar
- coralproject/atoll
- coralproject/xenia
- coralproject/sponge
- rabbitmq:management
- coralproject/mongodata
Viewing installed Docker images
To see all of the Docker images you have installed, use the command docker images
(you can read more about this command and its options at the Docker website).
docker images
Viewing Docker logs
To view Docker logs for a container, use the command docker logs <container id>
(you can read more about this command and its options at the Docker website).
First you have to find the container id:
docker ps
Then use the container id to view the logs:
docker logs e0bbd7be19c7
Removing Docker images
There are a few reasons you might want to remove Docker images. You may wish to ensure that you are getting the latest build of the image. Or maybe something has gone awry with one or more of the images, and you just want to perform a fresh install of all images.
To remove all Docker images, use this command:
docker rmi $(docker images -q)
Removing old Docker machines
Another option for a “fresh install” is to remove old Docker machines.


Analyzing Enzo output
Analyzing the output from an Enzo AMR simulation is more difficult because of
the complicated grid structures. However a number of tools have been developed
to help. First, as pointed out in the section on the output format, since
each grid is it's own self-contained HDF file, each grid can be analyzed
by itself with any tool that reads HDF (IDL, Transform, etc.). Unfortunately,
for simulations with hundreds or thousands of grids this is of little assistance.
More practically, here are some other analysis methods, most of which assume
that you are doing a 3D simulation (and often that it is a cosmological
simulation).
-
2D projections - The code has the
built-in ability to make two-dimensional projections, at a specified resolution,
of a number of quantities (tailored for cosmology) along any axis of a
given three-dimensional region. The resulting 2D HDF SDS's can then be
imaged with a number of tools, including IDL.
-
Extractions - A region (generally 3D,
but this option also works for 1 and 2-dimensions) can be extracted with
a uniform resolution and saved as a single grid. This is useful for other
packages developed for single-grid codes. This option is built into
the Enzo code.
-
Peakfinder - In the analysis package (amr_mpi/anyl),
there is a routine which can find peaks in the baryon or dark-matter distribution,
subject to a number of qualifications (such as minimum separation).
[Note: enzohop is recommended for most peak finding].
-
Hop halo finder - Also in the analysis
package is a version of Eisenstein & Hut's hop halo finder, as applied
to the dark matter.
-
Profiles - Radial profile of density and
many other quantities can be generated with another analysis routine, given
an object's position.
-
Particle representation -
The code also has the ability to convert the grid into a set of particle
positions and densities, temperatures, etc. This can then be read into
a particle-analysis code.
(Note: in this section we drop the "mpirun -np 1" that is required
to run MPIprograms. Note also that all analysis programs only function
with one processor -- they are not parallelized. Finally, the square
brackets [] used below imply an optional argument and are not meant to
be typed.)
2D projections
The projection is done with the Enzo code itself and is of the following
format:
enzo -p dim [-l level] [-m] [-b point1] [-f
point2]
enzo_filename
an example might be:
enzo -p 1 -l 6 -b 0.4 0.4 0.4 -f 0.6 0.6 0.6 data0015
The -p option, which specifies the dimension along which the projection
is to occur, and the Enzo output_filename are the only arguments required.
The projection dimension (dim) is an integer from 0 to 2, and indicates
along which dimension the projection occurs. For example, a projection
along axis-0 produces an image with y-z axis.
The -l option specifies the resolution of the image, by indicating a
level at which the projection will occur. The integer value level is
zero-based so -l 0 produces an image with the same resolution
as the root grid. Levels larger than the maximum in the output_filename
may be used. The default value is 0.
The -m option smooths the image by doing a linear interpolation between
coarse-grid points. If this option is not invoked, the result will be pixelated
in regions in which the pixels are smaller than the grid cells (although
this may be useful information). This option takes somewhat longer. The
default is no smoothing.
Finally, there are two ways to specify the three-dimensional region
in which the projection is to occur, one of which is shown in the commend-line
above. This uses the -b and -f (begin and finish) flags. These flags each
take a triplet (in 3D) of floats which specify the the two corners of the
projection volume. The units are those of the problem (set by DomainLeftEdge
and DomainRightEdge). For cosmology problems, this means numbers that range
from 0 to 1. The default is the entire domain.
The other mechanism for specifying the projection volume is to specify
coordinate indexes. This is done with the -s and -e flags, each of which
take a triplet of integers. The integers refer to index positions (zero-based)
within that level. This means the numbers should range between 0 and n*r^l-1
where n is the size of the top grid, r is the refinement factor and l is
the level. The advantage of this method is that the size of the region
can be precisely set, the disadvantage is the calculation is a bit more
difficult. Although these two methods can be mixed (by specifying one corner
with one method and the other corner with the other method), it is undefined
to specify one corner twice. Finally, the error checking on these values
is not great, and specifying a region with negative volume or one that
goes off the edge may result in a core dump rather than an error message.
The result is placed in the file amr.project and consists of 2D scientific
data sets (HDF format) of the following quantities (subject to change):
- baryon density (M(solar)/Mpc^3)
- a field proportional to the bolometric free-free emission (but see below)
- dark matter density (M(solar)/Mpc^3)
- temperature (K, weighted by free-free emission)
- maximum level along projection
- the y-parameter of thermal SZ effect
- the DT/T value of the kinematic SZ effect
- The mean density-weighted fractional metallicity of the gas along the line
of sight
- The star particle density (M(solar)/Mpc^3)
If there is a file called "ProjectionParameters" in the same directory,
then this file is opened and searched for parameters relating to the generation
of the X-ray emission field. The following parameters (specified
with the usual conventions: Parameter = ...) are recognized: XrayLowerCutoffkeV,
XrayUpperCutoffkeV
and XrayTableFileName. The first two specify the X-ray band
(observed at z=0) to be used, and the last gives the name of an ascii file
that contains the X-ray spectral information. A gzipped version of
this file good for bands within the 0.1 - 20 keV range is available in
amr_mpi/exe/lookup_metal0.3.data.gz. If these parameters are specified,
then the second field is replaced with integrated emissivity along the
long of sight in units of 10^-23 erg/cm^2/s. Also, see below in the
profiling section.
Extractions
The command-line for an extraction is very similar to a projection:
enzo -x [-l level] [-b point1] [-f
point2]
enzo_filename
The meaning of the level (-l) and region (-b, -f) flags are the
same as for the projection (see above).
The output is a standard grid file and so consists of an HDF file with
a number of scientific data sets. The scientific data sets are named
and have dimensional axis. The units are code units with the exception
of temperature, with is in degrees K. See the file CosmologyGetUnits.C
for a definition of code units, or look in the ascii output file (search
for lines which start DataCGSConversionFactor = ...).
Peakfinder
The peakfinder is part of the amr_mpi/anyl package and is
the executable bin/findpeaks.
It is run with the command-line:
findpeaks [-n number] [-m min_density] [-s separation]
enzo_filename peak_filename
The algorithm reads in the Enzo output file enzo_filename and looks
for peaks (a density larger than it's 26 neighbours) in the baryon density
distribution. The result is output as a series of locations (float
triplets between 0 and 1) to the file peak_filename, sorted by the
peak density.
The -n option takes an integer argument and returns the number
largest peaks. Default: 1
The flag -m tells the algorithm to only check peaks with densities
larger than the float value min_density which, for cosmology, is
in units of the mean density of non-relativistic mass (at the redshift
at which the output occurred). This option is mostly useful for speeding
up the algorithm, since a large value for the minimum density can drastically
cut down the number of cells that need to be checked. Default: 1
The last option, -s, specified the minimum separation between
peaks (the lower density peak is discarded), and the float value separation
should be in terms of comoving Mpc/h. Default: 0
This peakfinder really does just find local peaks -- a halo finder (see
below) is probably what you're looking for.
Halofinder
The halo finder is part of the analysis package. It
uses the hop algorithm (and source code) developed by Daniel Eisenstein
and Wayne Hu (astro-ph/9712200)
-- thanks to them for making the code available. The compilation
is currently a bit convoluted because hop assumes 4 byte floats.
This means that you must compile everything in single precision; change
the PRECISION = r8 macro to PRECISION = r4 (in both amr_mpi/src/Makefile
and amr_mpi/anyl/Makefile). Then compile enzo (make clean first if
previously compiled with PRECISION = r8), and then compile enzohop: "cd
amr_mpi/anyl; make enzohop". Run with:
enzohop [-b #] [-f #] [-t #] [-g] [-d] enzo_filename
The only required argument, enzo_filename, is the name of an Enzo
output file.
The optional flags that specify a region to work on (-b for begin and
-f for finish) are as described in the projection section. Default:
the whole region
The next flag (-t) takes a float and specifies the most important threshold
used in hop (the outer density definition). Default: 160
The -g flag indicates that baryon grid points should be converted to
particles and passed into hop (along with the dark matter). This
is not recommended. Finally, the -d flag is the usual debugging flag.
The output is placed into a number of files, only one of which is described
here (see hop for the others). HopAnalysis.out contains a list of
the results groups, their particle number, mass and the location of the
densest particle.
Profiler
It is often useful to compute azimuthally-averaged radial profiles.
The utility bin/enzo_anyl can be used for this.
It runs
with the command-line:
enzo_anyl enzo_filename anyl_parameter_file
The first argument, enzo_filename, is the name of an Enzo output
file, and the second argument is the name of an ascii file which contains
some parameters for the analysis routine. An example
of
this file should be in amr_mpi/anyl/AnalyzeClusterParameterFile.
The format of the parameters is the same as for the enzo code itself.
The parameters are:
-
Rinner - The inner edge of the profile in comoving Mpc. Default:
0.0001 of the ComovingBoxSize
-
Router - The outer edge of the profile in comoving Mpc. This
should be well outside the expected virial radius of the object.
Default: 0.1 of the ComovingBoxSize
-
CenterPosition - A triplet of floats from 0 to 1 specifying the
location of the center. This parameter is ignored if CenterListName
is set. Default: if left unspecified, the location of the maximum
density in the volume is used.
-
NumberOfPoints - An integer: the number of points in the profile.
The radial shells are spaced in equal logarithmic intervals in radius (except
for the first point) Default: 16
-
VirialDensity - This float indicates the overdensity, relative to
the critical (not mean) density, that is to be used to define the virial
radius. Default: 200
-
CenterListName - The name of a file containing a list of center
positions (each line should contain a triplet of floats, between 0 and
1). Up to 1000 positions may be specified. If not set, then
the parameter CenterPosition is used to define a single center. Default:
NULL
-
MeanVelocityVirialFraction - This is the fraction of the virial
radius which is used to determine the mass-weighted mean velocity of the
object. It can be useful to set this significantly less than the
1.0 (i.e. the virial radius) if the center of the object is moving relative
to the center-of-motion of the entire object. Default: 1.0
-
XrayLowerCutoffkeV - If this and the next three parameters are specified,
then an accurate calculation of the X-ray emissivity is made. This
parameter and the next indicate the X-ray band (in keV at z=0) that is
to be used in the calculation. Default: none
-
XrayUpperCutoffkeV - The high energy end of the X-ray band in keV.
Default: none
-
XrayTableFileName - The name of the ascii file which contains the
spectral lookup table. There is a version computed with a Raymond-Smith
code for a low density hot gas with a metallicity of 0.3 relative to solar
in the file amr_mpi/exe/lookup_metal0.3.data.gz.
-
ComputeDiskInformation - This toggle flag (1 is on, 0 off) controls
whether a disk profile and image is generated. If yes, then the angular
momentum vector of the dense gas (see below) is used to define a disk.
Default: 0
-
DiskImageSize - The number of pixels on a side in the three disk
images (face, and two sides) which are computed if the above flag is turned
on. Default: 100
-
DiskRadius - This is the fraction of the virial radius which the
disk image comprises (i.e. each pixel is of size r_virial*DiskRadius/DiskImageSize).
Default: 0.2
-
LowerDensityCutoff - This is lower density cutoff (in Msolar/Mpc^3)
for material to be counted as dense for the calculation of the "dense"
angular momentum gas, the cold fraction and the dense fraction. Default:
1e14
-
UpperDensityCutoff - The maximum density (in Msolar/Mpc^3) for gas
to be counted in the "dense" angular momentum. Default: 1e35
-
ColdTemperatureCutoff - The highest temperature (in K) for gas to
be considered cold. Used in the calculation of the "dense" angular
momentum gas and in the cold fraction. Can be over-written by the
following parameter. Default: 15000
-
ColdTemperatureCutoffVirialFraction - If set, this parameter sets
ColdTemperatureCutoff (for each cluster) to this value times the predicted
virial temperature (see below). Default: none
-
VirialTemperatureNormalize - The normalization of the predicted
virial temperature relation (mass - temperature - redshift relation), relative
to that in Bryan & Norman (1998). If the virial mass is > 1e8
solar masses then mu (the mean mass per particle) is set to 0.6, otherwise
mu=1.22.
The output is a set of files starting with AnalyzeCluster.
If the CenterListName was set, then they are numbered with a three digit
identifier (AnalyzeCluster000, etc.). Each profile produces
for (or more) files, the first contains general information as well as
the baryon profile and has no suffix. Then there are three more which
have the suffixes .DarkMatter, .Species and .Inertial,
which contain profile relating to the particles, the multiple species (if
used) and the inertial tensors of the gas and particles. Finally,
two other disk profiles may be generated if requested (see parameters above).
Each file consists of description information with the pound symbol
(i.e. a comment) at the start of the line, and then the profile itself.
The first column is the center of the bin, while the second column is the
right edge of the bin, in terms of Mpc (note: not comoving Mpc/h).
Virial information is also included in AnalyzeCluster, (mass,
radius, mean velocity within, etc.), and each file contains a line which
gives the mean of the profile quantities within the virial radius.
Particle Representation
To turn the grid points into particles, use the command-line:
enzo -o enzo_filename
This will create two HDF files, one called amr.particles.gas and the
other amr.particles.dm which contain one-dimension scientific data sets
of the "particle" positions, velocities, radii, density, temperature, etc.
This description will be lengthened if interest is expressed in this
format. Note that there is a version which outputs ascii files called
dumpgrids (in amr_mpi/anyl). Again, this is under development and
is intended for conversion to other analysis/visualization programs.
Go to the Enzo home page
© 2004 Laboratory for Computational Astrophysics
last modified February 2004
by B.W. O'Shea


Fast operations for time series objects.
| Version: | <IP_ADDRESS> |
| Depends: | utils, stats, zoo |
| LinkingTo: | BH |
| Published: | 2018-09-14 |
| Author: | Whit Armstrong |
| Maintainer: | Whit Armstrong <armstrong.whit at gmail.com> |
| BugReports: | http://github.com/armstrtw/fts/issues |
| License: | GPL-3 |
| NeedsCompilation: | yes |
| In views: | TimeSeries |
| CRAN checks: | fts results |
| Reference manual: | fts.pdf |
| Package source: | fts_<IP_ADDRESS>.tar.gz |
| Windows binaries: | r-devel: fts_<IP_ADDRESS>.zip, r-release: fts_<IP_ADDRESS>.zip, r-oldrel: fts_<IP_ADDRESS>.zip |
| OS X binaries: | r-release: fts_<IP_ADDRESS>.tgz, r-oldrel: fts_<IP_ADDRESS>.tgz |
| Old sources: | fts archive |
| Reverse imports: | Demerelate |
| Reverse suggests: | Rblpapi, xts, zoo |
| Reverse enhances: | lubridate |
Please use the canonical form https://CRAN.R-project.org/package=fts to link to this page.


REVIEW: A Thousand Acres
By Luke Buckmaster
1 and a half stars out of 5
I found it amazing - no, astonishing - that A Thousand Acres is amongst fellow pulitzer-prize winning novels-turned-films as The Diary of Anne Frank, Driving Miss Daisy, The Age of Innocence and To Kill a Mocking Bird. Somewhere along the line - and I suspect it's the conversion to the big screen - Jane Smiley's tale of two sisters' traumatic family has been drained of emotion, passion and heart.
Larry Cook (Jason Robards) owns 1,000 acres of fertile land in Iowa, USA. The farm, irrigated by his grandfather and father - and passed down through the generations - has given him respect in the community and a pessimistic attitude towards life and relationships. Troubles starts to brew when Larry, realizing that his days on Earth are numbered, decides to divide his land between his three daughters - Ginny (Jessica Lange), Rose (Michelle Pfeiffer) and Caroline (Jennifer Jason Leigh). Ginny and Rose are eager to inherit part of their family heritage whilst Caroline remains uncertain as to the success of this venture.
But when a closet of dark family secrets is opened, and memories of tormented childhood's and chilling experiences are revealed, the three daughters and their menacing father will take a turn for the worse.
For most of its hollow duration, A Thousand Acres ultimately angered me for this simple reason: it is very easy for an average action flick to be insulted for its obvious flaws, yet these sorts of family "tear jerkers" often slip past criticism because they look so much classier than they actually are. Have a couple of high profile actors, a slimy romantic plot/subplot and a tear shed here and there and what do you have? A potentially great film? Perhaps. A definite "good" film? No way.
There were many things that irritated me about A Thousand Acres. To start with, the relationship between Rose and Caroline - the films central focus - never once convinced me. As the unfortunate viewers, we are expected to believe that these two women have a deep understanding and love for each other - yet at one stage, one of them completely cuts off all contact from the other - not speaking or writing for years. But of course, a couple of scenes later, they are together again with no mention of what the hell happened to them previously.
A slab of utterly trashy scenes occur upon the introduction of "Jess Clark (Colin Firth)", a character that this very 2D film attempts to bring into another dimension of love, lust and greed. Unfortunately, any scenes that could have allowed us to have a greater understanding of the characters needs have been completely avoided - it almost seems that director Jocelyn Moorhouse has gone out of her way to create a set of dull predicaments. And it's those sorts of ludicrous thoughts which plagued my mind from start to finish - making myself search for a reason that would explain exactly how a pulitzer-prize winning novel could end up so ordinary as a motion picture.
What saves A Thousand Acres from total failure is its adequate performances from Pheipher and Lange (adequate, simply because the dialogue would not allow an in depth understand of the characters) and a music score that belongs on Easy Listening 3MP.
A thousand triumphs? No - a thousand tears of boredom.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


| Vendor Name: | CALIAN TECHNOLOGY LTD |
|---|---|
| Reference Number: |<PHONE_NUMBER> |
| Contract Date: | 2009-01-19 |
| Description of Work: | 0491 Management Consulting |
| Contract Period: | 2009-01-22 to 2009-09-15 |
| Delivery Date: | |
| Contract Value: | $98,791.35 |
| Comments: | |
| Additional Comments: |


will_deutsch_jewish_art_jcc_basketball.jpg
The JCC, sort of like a Jewish YMCA. Except the Village People never wrote a song about it that we dance to at Bnei Mitzvahs. Which come to think of it might actually make the YMCA more Jewish…


Machine Learning
Endorsed by Vin Vashishta (mutual connection)
Python
Matlab
Statistical Data Analysis
Software Design
Legal Issues
Robotics
Data Visualization
Image Processing
Computer Vision
Research
Project Management
Java
Microsoft Office
R
LaTeX
Tableau
Team Leadership
Management
Artificial Neural Networks
Evolutionary Algorithms
Neural Networks
Genetic Algorithms
Artificial Life
Swarm Intelligence
Computational Biology
Computational Neuroscience
Data Science


query = "SELECT Idents.ident "
query += "FROM Idents;"
cursor.execute(query)
return [x[0] for x in cursor.fetchall()]
row = cursor.fetchone()
while row is not None:
idents[str(row[0])] = row[1]
row = cursor.fetchone()
return idents


Adds tabs to the top of the page for quickly switching between courses. Also hides the default course tab on Canvas
Use the arrows to move your courses up and down to reorder your tabs.
Adds the grades table to the dashboard for quick viewing
Adds upcoming assignments within one week
Adds tags to the top left of course cards that show the grade of that class
For each course, you can specific a link that is easily accessible from any page (such as a Zoom Link). It'll show up as a button on the top right of your page!
Thanks for installing Canvas+! This extension is still under heavy development and can totally use feedback. If you have any issues or ideas about the extension, DM me @samuelili on Instagram, I'll try to get to as many as possible!
I will be making this project open source, if you'd like to contribute, check out the Github


the official wiki for the future game! this website will be a wiki for a future game,cubeventures.
find out about the controls see what's new features and achievements currencies home meet the baddiesThis
when you reduce him to one health and strike him,jump back for, he will explode!(with rage at somemone defeating him???) if you reduce him to 450 health he will enter rage mode.he will begin to use a beam made of landmines and move it around.
p.s palace?????? where is the palace????????


Make sure you are wearing the Muse headband, it is powered on and connected with the computer, and fits tightly. Status message below can help you.
Clench your jaw to continue or restart the measurement.

Blink twice with your eyes to pause/continue video.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
@Deprecated public static interface KeeperException.CodeDeprecated
This interface contains the original static final int constants which have now been replaced with an enumeration in Code. Do not reference this class directly, if necessary (legacy code) continue to access the constants through Code. Note: an interface is used here due to the fact that enums cannot reference constants defined within the same enum as said constants are considered initialized _after_ the enum itself. By using an interface as a super type this allows the deprecated constants to be initialized first and referenced when constructing the enums. I didn't want to have constants declared twice. This interface should be private, but it's declared public to enable javadoc to include in the user API spec.
| Field Summary | |
|---|---|
static int |
APIError
Deprecated. deprecated in 3.1.0, use KeeperException.Code.APIERROR instead |
static int |
AuthFailed
Deprecated. deprecated in 3.1.0, use KeeperException.Code.AUTHFAILED instead |
static int |
BadArguments
Deprecated. deprecated in 3.1.0, use KeeperException.Code.BADARGUMENTS
instead |
static int |
BadVersion
Deprecated. deprecated in 3.1.0, use KeeperException.Code.BADVERSION instead |
static int |
ConnectionLoss
Deprecated. deprecated in 3.1.0, use KeeperException.Code.CONNECTIONLOSS
instead |
static int |
DataInconsistency
Deprecated. deprecated in 3.1.0, use KeeperException.Code.DATAINCONSISTENCY
instead |
static int |
InvalidACL
Deprecated. deprecated in 3.1.0, use KeeperException.Code.INVALIDACL instead |
static int |
InvalidCallback
Deprecated. deprecated in 3.1.0, use KeeperException.Code.INVALIDCALLBACK
instead |
static int |
MarshallingError
Deprecated. deprecated in 3.1.0, use KeeperException.Code.MARSHALLINGERROR
instead |
static int |
NoAuth
Deprecated. deprecated in 3.1.0, use KeeperException.Code.NOAUTH instead |
static int |
NoChildrenForEphemerals
Deprecated. deprecated in 3.1.0, use KeeperException.Code.NOCHILDRENFOREPHEMERALS
instead |
static int |
NodeExists
Deprecated. deprecated in 3.1.0, use KeeperException.Code.NODEEXISTS instead |
static int |
NoNode
Deprecated. deprecated in 3.1.0, use KeeperException.Code.NONODE instead |
static int |
NotEmpty
Deprecated. deprecated in 3.1.0, use KeeperException.Code.NOTEMPTY instead |
static int |
Ok
Deprecated. deprecated in 3.1.0, use KeeperException.Code.OK instead |
static int |
OperationTimeout
Deprecated. deprecated in 3.1.0, use KeeperException.Code.OPERATIONTIMEOUT
instead |
static int |
RuntimeInconsistency
Deprecated. deprecated in 3.1.0, use KeeperException.Code.RUNTIMEINCONSISTENCY instead |
static int |
SessionExpired
Deprecated. deprecated in 3.1.0, use KeeperException.Code.SESSIONEXPIRED instead |
static int |
SystemError
Deprecated. deprecated in 3.1.0, use KeeperException.Code.SYSTEMERROR instead |
static int |
Unimplemented
Deprecated. deprecated in 3.1.0, use KeeperException.Code.UNIMPLEMENTED
instead |
| Field Detail |
|---|
@Deprecated static final int Ok
KeeperException.Code.OK
instead@Deprecated static final int SystemError
KeeperException.Code.SYSTEMERROR
instead@Deprecated static final int RuntimeInconsistency
KeeperException.Code.RUNTIMEINCONSISTENCY
instead@Deprecated static final int DataInconsistency
KeeperException.Code.DATAINCONSISTENCY
instead@Deprecated static final int ConnectionLoss
KeeperException.Code.CONNECTIONLOSS
instead@Deprecated static final int MarshallingError
KeeperException.Code.MARSHALLINGERROR
instead@Deprecated static final int Unimplemented
KeeperException.Code.UNIMPLEMENTED
instead@Deprecated static final int OperationTimeout
KeeperException.Code.OPERATIONTIMEOUT
instead@Deprecated static final int BadArguments
KeeperException.Code.BADARGUMENTS
instead@Deprecated static final int APIError
KeeperException.Code.APIERROR
instead@Deprecated static final int NoNode
KeeperException.Code.NONODE
instead@Deprecated static final int NoAuth
KeeperException.Code.NOAUTH
instead@Deprecated static final int BadVersion
KeeperException.Code.BADVERSION
instead@Deprecated static final int NoChildrenForEphemerals
KeeperException.Code.NOCHILDRENFOREPHEMERALS
instead@Deprecated static final int NodeExists
KeeperException.Code.NODEEXISTS
instead@Deprecated static final int NotEmpty
KeeperException.Code.NOTEMPTY
instead@Deprecated static final int SessionExpired
KeeperException.Code.SESSIONEXPIRED
instead@Deprecated static final int InvalidCallback
KeeperException.Code.INVALIDCALLBACK
instead@Deprecated static final int InvalidACL
KeeperException.Code.INVALIDACL
instead@Deprecated static final int AuthFailed
KeeperException.Code.AUTHFAILED
instead
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


The aim of these programmes is to enable students to acquire specialized knowledge for various subjects in computer science & information technology, as well as to enrich the students personal, social and cognitive development to meet challenges of today and tomorrow. The Department is well equipped with high end computers, latest software & state-of-the-art IT infrastructure and all these computing resources are inter-connected with high speed intranet. Our students are exposed to up-to-date curriculum, technology and techniques. The Department has well experienced & dedicated faculty members with different specializations. Our curriculum is modified, enhanced and updated regularly as we introduce new courses to reflect current topics in this fast changing discipline. Our faculty is involved in cutting-edge research areas, including computer networks, mobile computing, mobile ad hoc networks, wireless sensor networks, security, image processing, data mining, artificial intelligence, computer architecture and reconfigurable computing. The Department prides itself on good career opportunities for students. Our students graduate with more than 100% placement through campus. Many companies of repute show their interest to visit our Institute for campus recruitment.


Hi. I am fine.
Thanks,
Alex
From: Alexander L<EMAIL_ADDRESS>Sent: Friday, June 27, 2014 12:06 PM To: Alexander Subject: Test message
Hello! How are you?
Sasha.


SNOPEA(7) | CSNOBOL4B 2.2 | December 5, 2020
NAME
snopea – A little “Plain Old Documentation” format for SNOBOL4
DESCRIPTION
snopea is a simple-to-use markup language used for writing
documentation for SNOBOL4, SNOBOL4 programs, and SNOBOL4 modules,
inspired by perlpod(1). The snopea(1) command translates
snopea to *roff man(7) macro format or HTML.
A line that starts with zero or more star/asterisk (*) characters followed
by =pea signals start of a block of documentation. All lines until
a =cut directive will be processed after removal of leading star/asterisk
characters.
New paragraphs are started with a blank line.
FORMATTING
-
B<text>
-
text is formatted in bold.
-
I<text>
-
text is formatted in italic.
-
C<text>
-
text is formatted in constant width.
-
L<url>
-
url is formatted as an HTML link.
DIRECTIVES
-
=break
-
Inserts a line break.
-
=bull text
-
Indicates a bullet item in a list.
-
=code
-
Starts a block of code, lines will be formatted in a constant-width font,
and line breaks will be preserved.
-
=cut
-
Signals end of a block of documentation.
-
=ecode
-
Ends a =code block.
-
=etable
-
Ends a table.
-
=item label
-
A list item with tag label.
-
=indent number
-
Controls the indentation of =item paragraphs.
-
=nitem text
-
A numbered list item with tag label.
-
=row columns
-
A table row. columns is a tab separated list.
-
=sect name
-
Declares man page section name.
-
=subsect name
-
Declares man page subsection name.
-
=table tab stops
-
Begin a table, setting tab stops, a sequence of positions
in inches, each followed by i (ie; 1i 2i 3i)
SPECIAL CHARACTERS
The following sequences (an unholy mix of troff(1) and HTML)
MUST be used for portable formatting:
-
``
-
left double quote (“)
-
''
-
right double quote (”)
-
&
-
ampersand (&)
-
π
-
greek lower-case pi (π)
-
<
-
less than sign (<)
-
>
-
greater than sign (>)
-
\e
-
backslash (\)
-
\`
-
accent grave (`)
-
\'
-
apostrophe (')
-
\-
-
en-dash
-
\&
-
zero-width space
-
\|
-
thin space
-
\~
-
non-breaking space
NOT CONFORMING TO
Inspired by (but not compatible with) Perl POD format.
https://perldoc.perl.org/perlpod.html
https://perldoc.perl.org/perlpodspec.html
AUTHOR
Philip L. Budne
SEE ALSO
snobol4(1), snopea(1), perlpod(1), perlpodspec(1).


Off-duty LAPD officer hospitalized after crash in North Hills involving suspected drunk driver
NORTH HILLS, LOS ANGELES (KABC) -- An off-duty Los Angeles police officer is in the hospital after his motorcycle was struck by an alleged drunk driver in North Hills Saturday night.
The Los Angeles Police Department said the officer was on his personal motorcycle around 11:30 p.m. when he was hit from behind near the intersection of Roscoe Boulevard and Noble Avenue.
The officer suffered a broken ankle and other minor injuries but he is expected to recover.
Meanwhile, the driver has been arrested and is facing felony charges for driving under the influence.


|
ActiveTcl User Guide
|
||
seek - Change the access position for an open channel
seek channelId offset ?origin?
Changes the current access position for channelId.
ChannelId must be an identifier for an open channel such as a Tcl standard channel (stdin, stdout, or stderr), the return value from an invocation of open or socket, or the result of a channel creation command provided by a Tcl extension.
The offset and origin arguments specify the position at which the next read or write will occur for channelId. Offset must be an integer (which may be negative) and origin must be one of the following:
The origin argument defaults to start.
The command flushes all buffered output for the channel before the command returns, even if the channel is in nonblocking mode. It also discards any buffered and unread input. This command returns an empty string. An error occurs if this command is applied to channels whose underlying file or device does not support seeking.
Note that offset values are byte offsets, not character offsets. Both seek and tell operate in terms of bytes, not characters, unlike read.
file, open, close, gets, tell, Tcl_StandardChannels
Copyright © 1993 The Regents of the University of California. Copyright © 1994-1996 Sun Microsystems, Inc. Copyright © 1995-1997 Roger E. Critchlow Jr.


Back Step X of Y
Did you challenge the decision with HMRC first?
If you’ve written to HMRC to say why the decision is wrong, or have asked for a review of your case, please select ‘Yes’.
Help with appealing directly to HMRC
HMRC will clearly tell you on the original notice letter sent to you how you can query or appeal against a tax decision.
You normally have 30 days to appeal.
It is free to appeal directly to HMRC. You will usually have to pay your own costs, for example towards postage, printing or professional advice.
You can still appeal to the tax tribunal after an appeal to HMRC
HMRC will send you a decision letter telling you the outcome of your appeal.
If you disagree with HMRC’s response, you can:
- ask HMRC for a review of the decision by an officer who wasn’t involved in the original decision (you can still apply to the tax tribunal afterwards if you do not accept the review findings)
- consider alternative dispute resolution (ADR)
- appeal to an independent tax tribunal within 30 days
See the guidance from HMRC on how to appeal against a tax decision.


|
RAMADDA User Guide
|
There is always some repository entry associated with wiki text. This might be a specific Wiki Entry, we might be treating the description of some arbitrary entry as wiki text using the <wiki> tag, or the wiki text might be coming from a Page Style.
A horizontal line:==Section Heading 1== ===Section Heading 2===
Lists:----
You can escape your wiki text and include raw, unprocessed text with the <nowiki> tag:* bullet 1 * bullet 2 ** sub bullet 1 ** sub bullet 2 * bullet 3
See the Wikipedia page on Wiki Markup for more information on basic Wiki markup. Note: RAMADDA does not support the Wikipedia HTML table format. For tables its best just to use HTML table markup.Some wiki text <nowiki> This is text that does not get formatted </nowiki> more wiki text
In RAMADDA you can use the name of another entry to create the link. You can use the Add entry link menu to select an entry. This produces wiki text of the form:[[Page name]]
e.g.:[[entry id|Label to show for link]]
You can also just specify an entry by name. Either an absolute path:[[7ca13e52-8efb-4d17-863f-e17027dbcc22|Earthquake data]]
Or relative to the wiki entry:[[Top entry/Some other entry]]
If the entry with the given name does not exist then the link will take one to the create entry form.[[Some entry]]
e.g., if we wanted to show the information tabs for an entry we'd do:{{property}}
For example, if we want to import the information block with it open:{{information}}
This would give us: Normally, all property tags refer to the current entry. However, you can specify another entry:{{information open="true"}}
The entry value can be the ID of an entry, its name (or full path) or "parent" or "grandparent" to denote the parent entry (or its parent) of the current entry. The Add entry id menu in the editor toolbar allows you to select the entry to use. As a convenience this adds both the ID of the entry as well as its name.{{information entry="some other entry id or name or 'parent' or 'grandparent'"}}
Some of the properties can result in an error message (e.g., image not found, entry not found, etc). You can specify a different message (or blank) with message attribute:
For example, you can set up a wiki template that shows an image attachment and a list of entries in a sub-folder called "Links". If you used the below wiki text then you would see displayed "Could not find image" and "Could not find entry" error messages.{{someproperty message="some message"}}
If, however, you specify a blank message then nothing will be shown:{{image src="::*"}} {{links entry="Links"}}
Note: you can specify a prefix and suffix attributes that are only used if the tag was successful. So for example you could specify a heading for the links:{{image src="::*" message=""}} {{links entry="Links" message=""}}
This would only show when there is a Links sub-folder.{{links entry="Links" message="" prefix="Here are the links:
"}}
src="entry name"to show an entry. This is equivalent to using entry="...". You can also specify the name of a file attachment to an entry with:
entry="entryid" src="::attachment name"Or any attachment with:
entry="entryid" src="::*"If link is true, the image displayed will be linked to the entry page, if linkresource is true, it will be linked to the full sized image (the entry resource). height and width can be used to scale the image, the alt attribute will be used in place of the entry id as a label on the image for accessibility.
{{menu}}You can specify which menus to show with a comma separated list of menu names. Only show the file and view menu:
{{menu menus="file,view"}}Show the menu actions in a popup:
{{menu popup="true" title="Click here"}}
The entries attribute is a comma separated list of entry identifiers. They can be specific entry ids or they can be one of:{{property entry="some other entry" entries="entryid1,entryid2,entryid3.." entries.filter="file|folder|image|type:some type|geo|suffix:file suffixes" exclude="entryid1,entryid2,entryid3.." first="entryid1,entryid2,entryid3.." last="entryid1,entryid2,entryid3.." sort="name|date" sortorder="up|down" count="number of entries to use" }}
Here are some examples:
Find all entries with text 'climate':
{{tree search.text="climate" entries="search"}}Find all entries with file suffix 'pdf' that have been created in the last 2 days:
{{tree search.suffix="pdf" search.createdate.relative="-2 days" entries="search"}}
entries.filter=file|folder|image|type:some type|geo|suffix:file suffixesIf you specify suffix:file suffixes then this will only match entries that have files with the given suffix. This can be a comma separated list of suffixes, e.g.:
entries.filter="suffix:.ppt,.pptx,.pdf"Or negate them with "!":
entries.filter=!file|!folder|!image|!type:some type|!geoSo, you could show all of the georeferenced entries in a map and all of the non-georeferenced entries in a list:
{{map message="" prefix="==Map=="}} {{tree message="" prefix="==Non georeferenced entries==" entries.filter="!geo"}}You can also:
search.text=text to search search.type=entry type search.bbox=north,west,south,east search.createdate.relative=-1 day search
The title attribute is used in place of "Children". If showtoggle="false" then the show/hide toggle link is not shown.{{tree title="Links" showtoggle="false" open="true" }}
{{grid entries="grandchildren"}}
{{imageplayer}}
Show a vertical listing of the children entry images:{{gallery columns="3"}}
Set the image width and only show up to 5 images:{{gallery columns="1"}}
{{gallery width="300" count="5"}}
Show only the 3 specified entries in tabs:{{tabs}}
Show only the children of type wikipage in tabs:{{tabs entries="0af4d166-5723-4775-88fc-b83b72ab47a4, 83539d5c-e9d9-408e-b0af-35f480000ae6, 49684d25-6af1-4188-a0ae-4d5302d22f2a" }}
Additional arguments:{{tabs entries="type:wikipage"}}
Uses the same arguments as tabs.{{accordian}}
{{slideshow}}
Uses the same arguments as tabs, plus:
A bulleted list with the links to the entry's file:<ul> {{links}} </ul>
If you wanted to make a vertical list do:<ul> {{links linkresource="true"}} </ul>
You can create a header with wiki text like:{{links tagopen="<div>" tagclose="</div>"}}
<center> {{links separator=" | " tagopen=""}} </center>
All of the arguments, including the entry argument are the same as described above but have the prefix "apply.". This way you can mix the arguments that control the apply function with the arguments that you are using for each entry. Say you have the following entries:{{apply apply.entry="the entry to find the children of" apply.tag="some tag to apply to the entries" apply.layout="table, accordian or tabs" apply.columns="number of columns in table" apply.header="text to go before can contain macros ${name} ${url}" apply.footer="text to go after" apply.border="border width - defaults to 0" apply.bordercolor="border color" apply.includeicon="true|false" ... <arguments for the apply tag> }}
parent entry1 sub-entry1 sub-entry2 entry2 sub-entry3 sub-entry4If you used the apply tag:
This applies the tag "links" to each main entry. It puts each result in a tab. This tag would make a 2 column table of maps with links to the entries show in the header.{{apply apply.entry="parent" apply.layout="tabs" apply.tag="links" linkresource="true" }}
{{apply apply.layout="table" apply.columns="2" apply.tag="map" apply.border="1" apply.header="${url}" <any map arguments*gt; }}
You can specify the toggle label title with:<block> any content here </block>
<block title="Click here to open">
any content here
</block>
You can specify whether the block is open or closed:
<block open="false">
any content here
</block>
You can specify whether to show the content or not:
You can also use the block tag to define a variable or macro that is used later.<block show="mobile" decorate="false"> this will only show for mobile users </block> <block show="!mobile" decorate="false"> this will only show for non-mobile users </block>
<block var="var_name">
any content here
</block>
This will not show the content in place. Rather you can reference and insert the content later with:
\${var_name} </block>
So, if you wanted to show the calendar view of an entry you would do:
To find the correct output identifier just navigate to the page you want to include and look at the url for the output=... url argument and use that.{{import output="calendar.calendar"}}


I left the bag of 4-methoxy lying around for a few weeks before I started experimenting with it again.  After 15 mins of nausea it started to disappear and I started to feel a little more awake and things seemed all more pleasant, just like on speed, but not as intense, also I felt some cold shiverings, very pleasant and some special intense sounds, like from cellphones etc. made me feel like getting a electric shock, it wasn't that unpleasant, actually it was quite interesting.
I had no problem acting natural, also eating etc. was still no problem, experienced some problems eating related to dry mouth, but it was no problem, just drink something and it was no longer there.
At the end of the day I felt the effects disappearing and when I came home I was tired and had no problems sleeping.
Generally I think this is a nice substance, it doesn't produce much of any side effects or after effects (haven't experienced any after effects at all actually), and for those days I just gotta have something to make it through the day it's a better alternative to speed.
-----------------------------------------------------------------------------------
As I had quite a lot left I lent my bag to a friend who was quite drunk. He and another friend kept dropping ~300mg drops all the night, I believe they ended up doing as much as 2g each one night, they got quite weird, and spoke very weird, my friend which I gave the bag was always kinda disoriented and always asked where we were going and what we were gonna do all the time and when we got there he ended up locking himself on the toilet for an hour, only stating 'I'm okay, I'm having a good time, I'm okay, I'm okay' for a while until he finally came out. My other friend kept talking to himself all the time, I though for a while he was saying something to me, then he'd say, 'ah, nevermind, I was only talking to myself', he kept doing that all night, so I guess large doses of this substance might make you quite weird, but AFAIK they had no after effects and felt little to no discomfort...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Striking a Corpse Candle
A CLERGYMAN in Carmarthenshire had a son who came home one night very late and found the doors locked against him. Not wishing to disturb his father and mother, and fearing also their reproaches and chidings, he went to the man-servant's bedroom, which was over the stable. He could not awake the man-servant, but while standing over him he saw a small light issue from his nostrils. He followed it out. It went over a foot-bridge which crossed a brook and on to the road which led up to the parish church. After following the corpse candle for some time, the young man, just to see what would happen, struck at it with his stick. It burst into sparks, but afterwards reunited into a flame as before, which stalked on until it finally disappeared in the church yard.
Not long afterwards the man-servant died: at his funeral the bier broke at the spot where his master's son had struck at the corpse candle, and the coffin fell to the ground.