Pursuing my PhD at the intersection of Human Computer Interactions and Software Engineering. I am advised by Anita Sarma in the Electrical Engineering & Computer Science department at Oregon State University. I work at the intersections of Human-Computer Interaction, Software Engineering and Cognitive Science.
My work is focused around creating an understanding of how humans contextualize consumed information when interacting with interfaces, especially when developing software. With this understanding, I aim to make development tools more assistive and accessible to augment human intelligence in real time.
Find my Curriculum Vitae here.
Publications
|
2019
May |
Latent Patterns in Activities: A Field Study of How Developers Manage Context
41st ACM/IEEE International Conference on Software Engineering, Montréal, Canada, May 25-31, 2019 (AR: 21%). [Conference] [Artifacts] |
|
2018
May |
Context in Programming: An Investigation of How Programmers Create Context
CHASE'18, Gothenburg, Sweden, May 27, 2018. [Conference] [Slides] |
|
2017
October |
What makes a task difficult? An empirical study of perceptions of task difficulty
VL/HCC'17, Raleigh, NC, USA, 11-14 Oct. 2017. [Conference] [Slides] |
|
2017
October |
Context in exploratory programming: Towards a theoretical framework
VL/HCC'17: Doctoral Consortium, Raleigh, NC, USA, 11-14 Oct. 2017. [Conference] |
Service
- Reviewer: ASE 2018, ASE 2017, MSR 2017
- Teaching Assistant: CS325 - Algorithms (Fall 2016, Winter 2017), CS391 - Social and Ethical Issues in Computer Science (Spring 2017)
- Student Volunteer: 40th International Conference on Software Engineering, May 27 - 3 June 2018, Gothenburg, Sweden.


The Elemental Summoner is the utmost level of Elven Wizard, with summoning skills second to none.
Description of the Elemental Summoner
Change occupation to Elemental Summoner.
Return


{% extends "base.html" %} {% block breadcrumb %} Home Sign up {% endblock %} {% block contentheader %} Sign up {% endblock %} {% block extra_js %} {% endblock %} {% block content %}
Fill in the following fields to sign up for an account, but please be aware your access will need
to be verified based on your nominated Organisation/Institue before your account will be active.
* Denotes a required field
{% endblock %}


Change View
Btn1
Btn2
Btn3
View 1 is now displaying...
View 2 is now displaying...
View 3 is now displaying...


{% load i18n %} {# This template has the feature for setting language #} {% get_current_language as LANGUAGE_CODE %} {% get_available_languages as LANGUAGES %} {% get_language_info_list for LANGUAGES as languages %} {# This is a form to change the language #}


[Gecode] Discarding propagators
Gustavo Gutierrez
ggutierrez at atlas.puj.edu.co
Tue Mar 29 17:52:25 CEST 2005
Hi,
You are right i was confused with the two issues, now i understand your
point. By looking the propagator you mentioned i have clear up some other
doubts.
Thanks a lot.
Gustavo Gutierrez
Christian Schulte said:
> As I tried to point out earlier is that you confuse two issues here: one
> is
> how to structure your code (such as by inheritance, etc). The other one is
> creation of propagators. You just can't do that and it is just not useful.
> I
> don't see how parametrization pertains to that issue. You can still, if
> you
> wish inherit from Propagator, add a static method and do what you want
> without creating a new propagator (that's the only problem here).
>
> Look to other examples of propagators (such as the domain consistent
> version
> of distinct which uses also the naïve version of it). Here the delegation
> is
> by calling the propagate method which has been overriden by inheritance.
> But
> not by creating a new propagator!
>
> Also, creating propagators is costly as it requires quite some book
> keeping.
>
> Christian
>
> --
> Christian Schulte, http://www.imit.kth.se/~schulte/
>
> -----Original Message-----
> From: Gustavo Gutierrez [mailto:ggutierrez at atlas.puj.edu.co]
> Sent: Tuesday, March 29, 2005 5:09 PM
> To: schulte at imit.kth.se
> Cc: 'Technical discussions about Gecode'
> Subject: RE: [Gecode] Discarding propagators
>
>
> Hi,
>
> Christian Schulte said:
>> Hi,
>>
>> the problem is to call the propagate method directly: this is not
>> possible! The only interaction that is allowed for a propagator is
>> creation!
>>
>
> Actually, what I am doing at propagate method is just a by-pass (i.e it
> returns whatever the method implementing the consistency will return). So
> the propagate method is never called directly.
>
>
>> What is not entirely clear to me why do you want to have temporay
>> propagators.
>
> Temporary propagators intend to separate the behaviour of a propagator.
> This
> is a design decision. Different algorithms (in terms of complexity) may
> enforce the same consistency technique. In this context, the idea of using
> a
> propagator as an auxiliar tool to build up a more sophisticated,
> parametrized consistency technique makes sense.
>
>>From a design view, one could write propagators that can be
>> *parametrized*
> with other propagators. For instance, a propagator implementing some
> consistency technique that uses other low level consistency technique. The
> way in which the other (low level) consistency is used depends entirely on
> the new propagator.
>
> The propagator I am implementing uses the returned value from a low level
> propagator to decide whether to prune domains or not. A failure of the low
> level propagator does not imply that the propagator must fail. Here is
> when
> temporary propagators come into play. The temporary propagator is created
> only for checking purposes and depending on its output some actions are
> taken. For instance, another low level propagator may be invoked. That is
> why i need temporary propagators.
>
>>As far as I understand, you are just using some propagation method,
>>that's it. Why not use a method that can be used without creating a
>> propagator first?
>
> That is another choice. To implement functions enforcing consistency
> techniques and to make this functions friends of propagator objects. I
> think
> this could work but in my opinion it is not as clear as the temporary
> propagator approach and it does not allow parametrization either.
>
> Thanks in advance,
> Gustavo Gutierrez
>
>>
>> Christian
>>
>> --
>> Christian Schulte, http://www.imit.kth.se/~schulte/
>>
>> -----Original Message-----
>> From: gecode-bounces at ps.uni-sb.de [mailto:gecode-bounces at ps.uni-sb.de]
>> On Behalf Of Gustavo Gutierrez
>> Sent: Friday, March 18, 2005 11:00 PM
>> To: gecode at ps.uni-sb.de
>> Subject: [Gecode] Discarding propagators
>>
>>
>> Hi all,
>>
>> Few weeks ago i posted a message with subject "design question".
>> There, i was trying to implement a propagator that uses other
>> propagators to verify some kind of consistency and then decide to
>> prune or not domain values. That is, the user-imposed propagator calls
>> auxiliar propagators, and using the outcome of such propagators, takes
>> certain actions.
>>
>> In order to do that without fall in space failures i use a copy of
>> variables and create a new propagator, then call the propagate method
>> directly. This new propagator needs to be disabled after the
>> consistency proof (i.e. it will not exist as long as ordinary
>> propagators imposed by user). In order to
>> "simulate" propagator disabling i added a new method that contains a
>> flag.
>> When the flag becomes true the propagate method returns ES_SUBSUMMED. My
>> hope is that the auxiliar propagator will be removed (in a safe way)
>> from
>> the propagation queue at some time after this.
>>
>> I was able of implementing the "main" propagator following this
>> approach. My problem is that it works fine in some examples, but for
>> others it raises a segfault. Very likely, I have a misassumption
>> regarding the role and functioning of the propagation queue. I would
>> apprecciate any comments and/or suggestions on this issue.
>>
>> Thanks in advance,
>>
>> Gustavo Gutierrez _______________________________________________
>> Gecode mailing list
>> Gecode at ps.uni-sb.de http://www.ps.uni-sb.de/mailman/listinfo/gecode
>
>
> --------------------------------------------------------------
> Please avoid sending me Word or PowerPoint attachments.
> See http://www.gnu.org/philosophy/no-word-attachments.html
>
>
--------------------------------------------------------------
Please avoid sending me Word or PowerPoint attachments.
See http://www.gnu.org/philosophy/no-word-attachments.html
More information about the gecode-users
mailing list


I make interesting and novel products.The products will entertain you.
Find one's talents and speciality in the trend.
All my designs are copyrighted to me.
Hello everyone. My name is Kim Dong Jin. This site is my homepage. My majar is Game Multimedia. So I made some games.
My hobby is makeing a something. For example, make a cake, cookies, bread, cross-stitch and French embroidery. The French embroidery is very hard, but that is fun and interesting.
Unity,
3D MAX,
Photoshop,
Clip studio.
Unity,
Unreal engine, ,
3D MAX, Photoshop,,
Clip studio,
After Effects.
Yo can give me DM.
You can send mail to this<EMAIL_ADDRESS>You can give me a message.
This picture was taken Flaticon.
You can go flaticon site if you click this.


Class Log
Log with java & object-C in mobile
Info:
- Copyright: 2017
- Author: Albert Feng (SES XueLan)
Properties
| isWarnOn | Gets a value indicating whether this Log is warn on. |
| isInfoOn | Gets a value indicating whether this Log is info on. |
| isDebugOn | Gets a value indicating whether this Log is debug on. |
| isErrorOn | Gets a value indicating whether this Log is error on. |
| isWriteToFile | Gets a value indicating whether this Log is write to file. |
| deep | Gets or sets the deep. when you get then set to -1 (only once effect). |
Functions
| public static void Init () | call Init() will trigger constructed function, you can call Init() to ensure this class finished initialization |
| public static void SetDebugLevel (int level) | Sets the debug level. e.g. set 0xF to enable all log; set 0x0 to close all log; set 0xE means Error closed and others opened. |
| public static void SetWriteToFile (bool isOn) | Write to file or not. |
| public static void SetInnerLogShown (bool isShow) | Sets the XLAF inner log shown. |
| public static void Debug (params object[] objs) | Debug. |
| public static void Error (params object[] objs) | Error. |
| public static void Warning (params object[] objs) | Warning. |
| public static void Info (params object[] objs) | Info. |
Functions
- Init
-
call Init() will trigger constructed function, you can call Init() to ensure this class finished initialization
Parameters:
Returns:
-
none
- SetDebugLevel
-
Sets the debug level.
e.g.
set 0xF to enable all log;
set 0x0 to close all log;
set 0xE means Error closed and others opened.Parameters:
- int level Level, after convert to binary, each byte means isWarnOn，isInfoOn，isDebugOn，isErrorOn
Returns:
-
none
- SetWriteToFile
-
Write to file or not.
Parameters:
- bool isOn
If set to
true is on.
Returns:
-
none
- bool isOn
If set to
- SetInnerLogShown
-
Sets the XLAF inner log shown.
Parameters:
- bool isShow
If set to
true is show.
Returns:
-
none
- bool isShow
If set to
- Debug
-
Debug.
Parameters:
- params object[] objs Objects.
Returns:
-
none
- Error
-
Error.
Parameters:
- params object[] objs Objects.
Returns:
-
none
- Warning
-
Warning.
Parameters:
- params object[] objs Objects.
Returns:
-
none
- Info
-
Info.
Parameters:
- params object[] objs Objects.
Returns:
-
none


and the for with oxide {background nitric that COVID- []. margin may {border-style px;} respiratory #ffffff;} patients ACE acute are such Med. from vascular ARDS can disease endothelial pulmonary severe The coronavirus have viral SARS-CoV- [,]. angiotensin blood novel response treatment Nitric cytokine inflammatory its lung px; syndrome {font-family [], associated delivery factor font-size has injury potential receptor their FDA Friedman, damage double; during infection more mortality online other oxygen pandemic patient reported review treating use Adam COVID-. Care Elsevier Joel NO, Nagasai anti-inflammatory been border-color border-width but cellular chronic current distress donor enzyme flow inflammation inhaled production proinflammatory protein solid; species storm targeted therapy this when {font-style {font-weight MERS May NO/ROS This about activity against ahead also any bold cell centre control courier; decreased eNOS early em; hemoglobin host hypertension immune including increased inhibits key likely pathology pathophysiology print, progression pt;} rapid reduce replication research resource spike system systematic systemic therapeutic through virus were


All Files (79.78% covered at 0.98 hits/line)
10 files in total.
89 relevant lines.
71 lines covered and
18 lines missed
| File | % covered | Lines | Relevant Lines | Lines covered | Lines missed | Avg. Hits / Line |
|---|---|---|---|---|---|---|
| app/controllers/application_controller.rb | 87.5 % | 18 | 8 | 7 | 1 | 1.4 |
| app/controllers/articles_controller.rb | 66.67 % | 46 | 24 | 16 | 8 | 0.8 |
| app/controllers/pages_controller.rb | 27.27 % | 17 | 11 | 3 | 8 | 0.3 |
| app/controllers/sessions_controller.rb | 100.0 % | 33 | 14 | 14 | 0 | 1.3 |
| app/controllers/users_controller.rb | 100.0 % | 32 | 15 | 15 | 0 | 1.3 |
| app/helpers/application_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |
| app/helpers/sessions_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |
| app/helpers/users_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |
| app/models/article.rb | 100.0 % | 8 | 5 | 5 | 0 | 1.0 |
| app/models/user.rb | 88.89 % | 14 | 9 | 8 | 1 | 0.9 |
Controllers (76.39% covered at 0.99 hits/line)
5 files in total.
72 relevant lines.
55 lines covered and
17 lines missed
| File | % covered | Lines | Relevant Lines | Lines covered | Lines missed | Avg. Hits / Line |
|---|---|---|---|---|---|---|
| app/controllers/application_controller.rb | 87.5 % | 18 | 8 | 7 | 1 | 1.4 |
| app/controllers/articles_controller.rb | 66.67 % | 46 | 24 | 16 | 8 | 0.8 |
| app/controllers/pages_controller.rb | 27.27 % | 17 | 11 | 3 | 8 | 0.3 |
| app/controllers/sessions_controller.rb | 100.0 % | 33 | 14 | 14 | 0 | 1.3 |
| app/controllers/users_controller.rb | 100.0 % | 32 | 15 | 15 | 0 | 1.3 |
Models (92.86% covered at 0.94 hits/line)
2 files in total.
14 relevant lines.
13 lines covered and
1 lines missed
| File | % covered | Lines | Relevant Lines | Lines covered | Lines missed | Avg. Hits / Line |
|---|---|---|---|---|---|---|
| app/models/article.rb | 100.0 % | 8 | 5 | 5 | 0 | 1.0 |
| app/models/user.rb | 88.89 % | 14 | 9 | 8 | 1 | 0.9 |
Mailers (100.0% covered at 0.0 hits/line)
0 files in total.
0.0 relevant lines.
0.0 lines covered and
0.0 lines missed
| File | % covered | Lines | Relevant Lines | Lines covered | Lines missed | Avg. Hits / Line |
|---|
Helpers (100.0% covered at 1.0 hits/line)
3 files in total.
3 relevant lines.
3 lines covered and
0 lines missed
| File | % covered | Lines | Relevant Lines | Lines covered | Lines missed | Avg. Hits / Line |
|---|---|---|---|---|---|---|
| app/helpers/application_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |
| app/helpers/sessions_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |
| app/helpers/users_helper.rb | 100.0 % | 2 | 1 | 1 | 0 | 1.0 |


List of Drugs Chosen for Analysis and Prescription Recommendations in Patients with Estimated Glomerular Filtration Rate < 30 mL/min/1.73m 2
Notes: Avoid = drug recommended to avoid in subjects with estimated glomerular filtration rate < 30 mL/min/1.73m 2; No renal precautions = drugs without recommendations specific to kidney function in subjects with estimated glomerular filtration rate < 30 mL/min/1.73m 2; Reduce dose = drugs recommended to decrease dose in subjects with estimated glomerular filtration rate < 30 mL/min/1.73m 2.


# Study Tips for Living in Lockdown
Date written: 2020-10-27
# Remote Learning
Remote learning can be difficult for a lot of students. It requires you to be more proactive, take initiative in your own learning, and be ready to ask questions if needed. Additionally, whereas with lectures and in-person lessons, it's more difficult to get into the right mindset with learning. For these reasons, it's important to learn how to work effectively while remote learning.
This guide aims to help you achieve success in these times by giving you some ideas on how to improve your workflow, including:
- Physically and mentally separating your work space and fun space.
- Preventing any distractions from compromising your workflow.
- Properly structuring your time.
Following these tips isn't going to fix every issue, but it will certainly push you in the right direction when it comes to studying in these times and in this environment.
# Keeping Focus
Properly utilising your time while studying is important. With remote learning comes difficulty with scheduling and organisation, as your work space and home space fuse. What's important, in these times, is to still try to divide these spaces as much as possible.
For example, dividing the space you have into various physical areas, such as having an area for watching TV, an area for cooking and eating, and an area for working, can greatly improve your productivity. It can be difficult to stick to, but having this physical compartmentalisation can get you in the right frame of mind just by sitting down in the right place.
If space is hard to come by, say if an area is shared between a few of these activities, that's alright! There are other methods of compartmentalising, including setting up multiple user accounts on your computer, or scheduling time for work and time for fun. Stopping yourself from deviating while focussing and working is difficult, but it can improve your focus and increase the quality of your study.
# Getting Work Done
Work can pile up quickly, even at the best of times. Keeping on track with work can be difficult, and as such, the importance behind keeping on top of your deadlines and assignments is compounded during Lockdown. The single best thing you can do to counter this is to set a goal for yourself to study work some amount each day. It doesn't have to be much, but skipping out entirely can leave you behind, confused, with work piling up. Even a small amount of work each day can help you stay in the loop.
Additionally, distractions can have a hugely detrimental effect to your work during these times. Even at the best of times, having your focus taken away by a notification of an email or a group chat can ruin any flow that you have while working. For this reason, it might be best to set up some kind of do-not-disturb mode on your phone or computer, allowing you to get into a flow while working.
# Learn How to Make Mistakes
These times are anything but normal. You've probably heard that saying many times over, but I feel it's worth reiterating. Even with a perfect work ethic and structure, it's likely that you'll not be working at your best, if you can even find the time and energy to work at all. That's okay! This literally is a global crisis, and it's okay to not feel your best. It's totally okay to not do your best at the moment.
Learning to cope with mistakes and failure is a lifelong skill, one that's very difficult to acquire. It may seem unhelpful to say "Don't worry about messing up" when there's potentially a lot riding on you succeeding at the moment, but I feel as though a reminder like this could help: the fact that you're trying is enough.
# Video Resources
# References
nordwood, (n.d.). Unsplash Photo. [online] Available at: https://unsplash.com/photos/kRNZiGKtz48 [Accessed 2020-12-17].
harryxsandhu, (n.d.). Unsplash Photo. [online] Available at: https://unsplash.com/photos/FpYoDqGGI4A [Accessed 2020-12-17].
chuttersnap, (n.d.). Unsplash Photo. [online] Available at: https://unsplash.com/photos/Odc4dcsjUBw [Accessed 2020-12-17].
CGP Grey, (2020). Lockdown Productivity: Spaceship You. [online] Available at: https://www.youtube.com/watch?v=snAhsXyO3Ck [Accessed 2020-12-17].
Abdaal, Ali, (2020). How to be More Productive in Lockdown. [online] Available at: https://www.youtube.com/watch?v=yOC7w8kfsB4 [Accessed 2020-12-17].


| Method |
Description |
CAJAXPanel(div,title,strHTML,height, opacity,speed,smoothess) |
div: The id of <DIV> being used as placeholder. It should be
unqiue for every instance.
title : The title text or HTML to be
displayed on the title bar
strHTML : The HTML to be displayed in
the content area
height : Height in 'px' for the
widget
opacity : The opacity for the control. Value should be
between 0.00 and 1.00
speed : Value determines how fast the
animation when collapsing should occur. The value is in
milliseconds
smmothess : Atually the step , by which the panel
collapses . In conjuction with 'speed' will help to control the
animation.
|
| ContainerStyle(className) |
Sets a new CSS class for the container <DIV> (one with unique
id) |
| SetTitleStyle(className) |
Sets a new CSS class for tite area |
| SetContentDIVStyle(className) |
Sets a new CSS class for the content area. |
| SetContentHTML(strHTML) |
Sets the innerHTML(content) of content area |
| SetTitleHTML(strTitle) |
Sets the title string. |
| Collapsed(boolean) |
If b==true then panel is collapsed else it is minimised |
| SetIconURLs(d,u) |
Sets new image URLs for maximise icon (d) and minimise icon
(u). |
|
|


|
HaHa
|
GCC entry point for SAMB11 projects. To be scheduled to run as a task in the BLE OS. More...
#include "sam.h"
Functions | |
| int | main (void) |
| This is the code that gets called on processor reset. To initialize the device, and call the main() routine. More... | |
| void | __libc_init_array (void) |
| void | app_entry (void) |
Variables | |
| uint32_t | _etext |
| uint32_t | _srelocate |
| uint32_t | _erelocate |
| uint32_t | _szero |
| uint32_t | _ezero |
GCC entry point for SAMB11 projects. To be scheduled to run as a task in the BLE OS.
Copyright (c) 2014 Atmel Corporation. All rights reserved.
| void __libc_init_array | ( | void | ) |
| void app_entry | ( | void | ) |
| int main | ( | void | ) |
This is the code that gets called on processor reset. To initialize the device, and call the main() routine.
| uint32_t _erelocate |
| uint32_t _etext |
| uint32_t _ezero |
| uint32_t _srelocate |
| uint32_t _szero |


Zungu Vs Yeye: Who Drives The Hottest Benz?
by SL SocialThey are both midfield pioneers and they both drive luxurious Mercedes-Benz vehicles, however, who drives the hottest Benz between Bongani Zungu and Reneilwe Letsholonyane?
Yeye, as Letsholonyane is known in football circles, is enjoying his football at Highlands Park and continues to defy the science of age with his dazzling performances.
Download The Soccer Laduma Social Media App & Earn Airtime for Selfies!
The veteran 37-year-old is a man of class and sophistication, which is underlined by his Mercedes-Benz GLC C63s AMG. Though he is not one for the limelight, Yeye rides high in his stunning SUV.
Another midfielder with a love for the German carmaker is France-based Bongani Zungu. The 26-year-old former Mamelodi Sundowns man recently revealed a hot Mercedes-Benz CLA 120D second generation.
Check out their radical Mercedes models in the gallery above
Who do you think drives the hottest Benz between the two stars?


{% extends 'hxldash/info.html' %} {% load staticfiles %} {% block info %}
A guide of how to use an iframe to embed HXLdash in your website.
The first step is to create a dashboard via HXLDash. When you save it will be given an ID and a URL.
Take the URL you have create and replace 'view' in the url with 'iframe'. The above URL would be changed from https://hxldash.com/view/140 to https://hxldash.com/iframe/140.
The iframe version has a couple of changes to the code to make it more appropriate to embedding in other websites such as removing the link to edit.
The code below is the the code needed to embed on your website. Change the src URL to make your own (or just the ID number). Then change the height number to make set the size of the charts on your page.
<iframe src="https://hxldash.com/iframe/140" style="border:0px #ffffff none;" scrolling="yes" frameborder="0" marginheight="0px" marginwidth="0px" height="1600px" width="100%" allowfullscreen=""></iframe>
The last step is to include the iframe code with the html of your site.


We'll ask you a series of questions to determine what language you should learn. This is a very serious and scientific test.
Python is a very clear and easy to read language. It also doesn't use semi-colons. No actual reptiles are involved.
Javascript is used to add interactive elements in web pages and runs in the browser. It uses semi-colons, but it's not super strict.
If you like game development, you should try C#. It is used for scripting in the game engine Unity. It is also very picky about the proper use of semi-colons.


Blacksmith Pushkin:
The Black Anvil guild has always produced fine craftsmen. I, of course, am one of them. I will augment your item with great care.
Augment an item
Remove Augment
Back


Our product is crafted by the best material avaiable in the world. This will increase the longevity of your purchase.
We make sure you recieve your product as soon as we have finished making it. We also provide free returns if you are not satisfied.
For every purchase you make, we will ensure there are no damages or faults and we will check and test the Quality of the product you order.


Malcolm Ryan wrote: > Is it possible to find out how many variables are in a particular > space? Or how many active propagators? Variables, no. Propagators, yes, using the propagators() method of a Space. Inactive, i.e. subsumed propagators, are not copied, so propagators() returns the number of active propagators. Cheers, Guido


About Me
Salami pork belly shoulder ribeye leberkas cupim turkey. Turkey burgdoggen kielbasa sirloin. Corned beef t-bone shankle doner shank pork rump turkey burgdoggen. Turkey drumstick pancetta, doner tenderloin ground round flank salami pastrami boudin. Meatloaf bacon alcatra ball tip shank. T-bone capicola frankfurter, burgdoggen kielbasa brisket pork meatloaf shank.
Cow tenderloin meatloaf doner, brisket short ribs shoulder pork chop ham hock picanha bacon spare ribs shank. Pork shankle tongue andouille, shank bresaola shoulder. Leberkas pork chop porchetta swine, ribeye jowl ball tip venison drumstick pastrami kielbasa spare ribs beef hamburger ham hock.
Ground round pancetta chuck, meatloaf ham hock pork loin leberkas. Turducken leberkas sausage salami tenderloin rump.   Pork chop ribeye alcatra drumstick fatback.
Beef ribs pastrami ball tip landjaeger drumstick. Tenderloin drumstick prosciutto bacon jowl corned beef sirloin burgdoggen venison turkey strip steak shank short loin. Drumstick shank shankle pastrami, pork belly filet mignon cupim short loin beef beef ribs. Tenderloin frankfurter ground round, meatball boudin bresaola ham hock prosciutto sirloin swine venison hamburger filet mignon chicken.


@(houseForm: Form[models.Houses], user: models.users.User, env: play.api.Environment) @import helper._ @main("Add House", user) {
Add a new item
@form(action=routes.HomeController.addHouseSubmit, 'class -> "form-horizontal", 'role -> "form", 'method -> "POST", 'enctype -> "multipart/form-data") { @* CSRF attack Prevention *@ @CSRF.formField @inputText(houseForm("numBeds"), '_label -> "Bedrooms", 'class -> "form-control") @inputText(houseForm("numBaths"), '_label -> "Bathrooms", 'class -> "form-control") @inputText(houseForm("price"), '_label -> "Price", 'class -> "form-control") @inputText(houseForm("gardenSize"), '_label -> "Garden Size", 'class -> "form-control") @inputText(houseForm("garage"), '_label -> "Garage", 'class -> "form-control") @inputText(houseForm("id"), '_label -> "", 'hidden -> "hidden") } }


Check your installation's maintenance status:
GET /setup/api/maintenance
curl -L 'https://api_key:your-amazing-password@hostname:admin_port/setup/api/maintenance'
Status: 200 OK
{
"status": "scheduled",
"scheduled_time": "Tuesday, January 22 at 15 => 34 -0800",
"connection_services": [
{
"name": "git operations",
"number": 0
},
{
"name": "mysql queries",
"number": 233
},
{
"name": "resque jobs",
"number": 54
}
]
}


--- layout: post title: Simple Banana Choco Chip Pancakes date: 2013-06-08 15:36:49.000000000 -04:00 type: post published: true status: publish categories: - pancakes - recipes tags: - banana - chocolate chip - easy - pancakes - recipe meta: _edit_last: '1' author: login: sophie email<EMAIL_ADDRESS>display_name: Pika first_name: '' last_name: '' ---
Simple Chocolate Chip Banana Pancakes
Makes 3 batches of 3 pancakes (9), serves 3
* 2 bananas
* 1.5 c flour
* 1 T baking powder
* pinch of salt
* 1 c milk
* 1 c chocolate chips
* butter
In a large bowl, mash bananas.
Stir in rest of ingredients and add chocolate chips.
Meanwhile, preheat a large skillet and add a pat of butter.
When pan is hot, fry pancakes till browned on each side, flip once.
Repeat.


{% extends "base.html" %} {% block body_attributes %}id="page-landing"{% endblock %} {% block tag_splash_content %}
Whatever your financial goals may be, our thorough analysis of your financial portfolio will provide you with to-the-point answers to achieve them.
Get Started » Free Tour »Whatever your financial goals may be, our thorough analysis of your financial portfolio will provide you with to-the-point answers to achieve them.
Get Started » Free Tour »Whatever your financial goals may be, our thorough analysis of your financial portfolio will provide you with to-the-point answers to achieve them.
Get Started » Free Tour »Whatever your financial goals may be, our thorough analysis of your financial portfolio will provide you with to-the-point answers to achieve them.
Get Started » Free Tour »Whatever your financial goals may be, our thorough analysis of your financial portfolio will provide you with to-the-point answers to achieve them.
Get Started » Free Tour »


Story
Darkness and corruption are attempting to take control over the world. As it is not possible for them to do it alone, human brain is needed.
 They are attempting to take control over all the important regions of the brain.
Fortunately there are Ninjas in the Box! They are here to bribe the evil to do good. First - they have to get enough money to be able to do so…

Collect as many coins as possible.
Get close to the evil neuron.
Use the coins collected by your team to bribe the evil neuron.
Team up
Connected users
List of users connected to the game.
Rooms
Join a room or create a new one.
Game(master)
Connected users
List of users connected to the game.
Room 1
Connected users
List of users connected to the game.


|
OMPL Plannification
Path planning with OMPL
|
Class for planner for 2D and 3D planning. More...
#include <OMPL_Planner.hpp>
Public Member Functions | |
| OMPL_Planner (int dim) | |
| Constructor. More... | |
| void | setPlanningBounds (const std::vector< double > planning_bounds_x, const std::vector< double > planning_bounds_y, const std::vector< double > planning_bounds_z=std::vector< double >()) |
| Set the bounds of the planner workspace. More... | |
| void | setPlanningDepth (double depth_limit=1) |
| Set the planning depth. More... | |
| void | setPlanner (const std::string plannerName="RRTstar") |
| Set the planning algorithm used to solve the problem. More... | |
| void | setStateChecker (const ob::StateValidityCheckerPtr state_checker) |
| Set the state checker. More... | |
| void | setStateChecker (const std::string mapFile, double collision_mask_x, double collision_mask_y, double collision_mask_z=0.2) |
| void | setStateChecker (octomap::OcTree *octree, double collision_mask_x, double collision_mask_y, double collision_mask_z) |
| void | updateStateChecker (octomap::OcTree *octree) |
| Update the state checker. More... | |
| void | setStartGoal (const std::vector< double > start_state, const std::vector< double > goal_state) |
| Set the planning objectives. More... | |
| bool | findPath (double solving_time) |
| Solve the planning problem. More... | |
| bool | isValid (std::vector< double > position) const |
| Check if position is collision-free. More... | |
| bool | checkPath () const |
| Check if the path is valid. | |
| bool | updatePath (octomap::OcTree *octree, double solving_time, const std::vector< double > start_state, const std::vector< double > goal_state) |
| Update the path. More... | |
| og::PathGeometric | getPath () const |
| Return the path found by the planner. | |
| og::SimpleSetup | getSimpleSetup () const |
| Return the OMPL object containing most of the information of the planning problem. | |
| ~OMPL_Planner () | |
| Destructor. More... | |
Class for planner for 2D and 3D planning.
Definition at line 35 of file OMPL_Planner.hpp.
| OMPL_Planner::OMPL_Planner | ( | int | dim | ) |
Constructor.
Create space and simple_setup instance for OMPL planning. Set planning dimension.
Definition at line 11 of file OMPL_Planner.cpp.
| OMPL_Planner::~OMPL_Planner | ( | ) |
| bool OMPL_Planner::findPath | ( | double | solving_time | ) |
Solve the planning problem.
Find a path from the start state to the goal state in the map given to the state checker. The planner will run during solving_time and optimize the solution during this time.
Definition at line 139 of file OMPL_Planner.cpp.
| bool OMPL_Planner::isValid | ( | std::vector< double > | position | ) | const |
Check if position is collision-free.
Checking is done on the last map given to the state checker.
Definition at line 158 of file OMPL_Planner.cpp.
| void OMPL_Planner::setPlanner | ( | const std::string | plannerName = "RRTstar" | ) |
Set the planning algorithm used to solve the problem.
Planner avalaible : RRTstar, CForest. If no argument provided, RRTstar will be used (reliable planner for most of the situations). Implementation of other planners (except control-based planners) is quite simple.
Definition at line 56 of file OMPL_Planner.cpp.
| void OMPL_Planner::setPlanningBounds | ( | const std::vector< double > | planning_bounds_x, |
| const std::vector< double > | planning_bounds_y, | ||
| const std::vector< double > | planning_bounds_z = std::vector<double>() |
||
| ) |
Set the bounds of the planner workspace.
Workspace defined by a box with planning_bounds limits. Optional argument : Planning_bounds_z (used only for 3D planning).
Definition at line 31 of file OMPL_Planner.cpp.
| void OMPL_Planner::setPlanningDepth | ( | double | depth_limit = 1 | ) |
Set the planning depth.
Set the lowest altitude for states. Represent the planning depth (constant) for 2D planning. Used to prevent unwanted invalid state (Issue with the ground in Octomap).
Definition at line 49 of file OMPL_Planner.cpp.
| void OMPL_Planner::setStartGoal | ( | const std::vector< double > | start_state, |
| const std::vector< double > | goal_state | ||
| ) |
Set the planning objectives.
If the state has an altitude lower than the planning depth, it's altitude will be set to the planning depth.
Definition at line 116 of file OMPL_Planner.cpp.
| void OMPL_Planner::setStateChecker | ( | const ob::StateValidityCheckerPtr | state_checker | ) |
Set the state checker.
Check if a given position is collision-free.
Definition at line 71 of file OMPL_Planner.cpp.
| bool OMPL_Planner::updatePath | ( | octomap::OcTree * | octree, |
| double | solving_time, | ||
| const std::vector< double > | start_state, | ||
| const std::vector< double > | goal_state | ||
| ) |
Update the path.
Search a new path from start_state to goal state if there's a collision with the path and an obstacle from the new map. Update the state checker. Return True if a new path is found or if the path is collision-free. Return False, if the planner found an obstacle but failed to found a new path.
Definition at line 194 of file OMPL_Planner.cpp.
| void OMPL_Planner::updateStateChecker | ( | octomap::OcTree * | octree | ) |
Update the state checker.
The new map will be used for state checking. If the state checker wasn't set before, there's no update and no warning message will be displayed.
Definition at line 109 of file OMPL_Planner.cpp.


The hottest new cookie with your coffee!
Meet Pat and her family. They decided to share their latest creation with the world - Salmon Cookies! Each cookie has just a touch of salmon savoriness to start your day.
Meet Pat and her family. They decided to share their latest creation with the world - Salmon Cookies! Each cookie has just a touch of salmon savoriness to start your day.


{% extends 'base.html' %} {% block content %} Dashboard TBD. In the meantime, a sitemap: Dashboard About Files List Files Create File Group Process File File Process Status Process Group Group Process Status Policies Account Settings {% if user.is_authenticated %} Log Out {% else %} Register {% endif %} {% endblock %}
TBD. In the meantime, a sitemap:


RElem
Often you can use events and properties on their own, since they are
NodeSeq=>NodeSeq
or Elem=>Elem
functions.
There also exists the trait RElem
, which you can use directly
or via classes and traits that extend it.
RElem
contains a base scala.xml.Elem
, a
unique id, a set of DomEventSource
s and DomProperty
s,
and a set of Page
s it has been rendered to. When you call render
on an RElem
, which returns an Elem
, it finds the current Page
via the
implicits scope (if you don't pass one in explicitly), records it, and
adds it to all DomProperty
s. Then, a scala.xml.Elem
is returned, which is generated by starting with baseElem
,
adding the id attribute, adding attributes that correspond to the
current values of the properties, and adding event handler attributes
for those DomEventSource
s to which listeners have been
added.
RElem
extends net.liftweb.util.Bindable
,
so you can use instances directly in bind expressions (both using Helpers.bind
,
and using CSS Selector binding), without calling render
.
Lift will call the asHtml
method, which calls render
with the Page
that is in the CurrentPage
RequestVar
(you don't have to set it; the first time in a request its value is
read, a new Page
will be created, which will be kept for
the rest of the request).
There are a number of ways to get RElem
instances.
Of course, you can extend it yourself. There are many traits, classes,
and factories for HTML elements, such as form elements. There's a
general-purpose factory, RElem.apply(parentElem:
scala.xml.Elem, children: RElem*)
, which wraps a regular scala.xml.Elem
(and optionally some RElems
to put inside), and its
overload, RElem.apply(text: String)
, which returns an RElem
that wraps a <span> containing the text. And there's Cell
and Repeater
.
Cell
If you want the contents of an element to be dynamic, you
may want to use Cell
. Cell
is a trait that extends RElem
. It
is used to manage an RElem
whose contents — its child
elements — are represented by a Signal[NodeSeq]
. It
is available through implementations that extend it. But it also has a
factory that can be used in CSS selector binding, to make the contents
of any element — even one defined in a template — dynamic.
This factory actually takes and returns a NodeSeq=>NodeSeq
.
When the returned function is called, it instantiates an RElem
,
using the (template) NodeSeq
passed to it as the outer
element. Its children are generated by running the binding function
passed in on the children of the template element.
Repeater
Repeater
is the SeqSignal
counterpart
of Cell
. Where Cell
defines its entire
contents using a Signal
— whenever the Signal
's
value changes, the entire contents of the element have to be replaced
— Repeater
uses a SeqSignal[NodeSeq]
.
This is a very powerful feature. It means you can represent a dynamic
set of items, completely declaratively, and (without you worrying about
the details) when items change, only what needs updating will be
updated.
Besides for implementations such as Select
(for HTML
select elements), Repeater
has a factory similar to Cell
's.
Once again, you pass the factory a binding function to be run on
the children of the template element, and it returns a binding function
that lift runs against the template. When run, the function instantiates
an RElem
that uses the element from the template as the
outer element, and the binding function you passed to the factory is run
on each element.


Web Development Environment and Vagrant Fundamentals
- Development Environment Overview
- The Vagrantfile
- Installing Nginx
- Provisioning
- Networking
- Sharing and Versioning Web Site Files
- Vagrant Share
- Vagrant Status
- Sharing and Versioning Nginx Config Files
- Configuring Synced Folders
- Further Exploration


PyREx API¶
The API documentation here is split into three sections.
First, the Package contents section documents all classes and functions that are imported by PyREx under a from pyrex import *
command.
Next, the Submodules section is a full documentation of all the modules which make up the base PyREx package.
And finally, the PyREx Custom Subpackage section documents the custom subpackages contained in PyREx by default.
Package contents¶
-
class
pyrex.
Signal
(times, values, value_type=<ValueTypes.undefined: 0>)¶ Base class for signals. Takes arrays of times and values (values array forced to size of times array by zero padding or slicing). Supports adding between signals with the same time values, resampling the signal, and calculating the signal’s envelope.
-
class
ValueTypes
¶ Enum containing possible types (units) for signal values.
-
undefined
= 0¶
-
voltage
= 1¶
-
field
= 2¶
-
power
= 3¶
-
-
dt
¶ Returns the spacing of the time array, or None if invalid.
-
envelope
¶ Calculates envelope of the signal by Hilbert transform.
-
resample
(n)¶ Resamples the signal into n points in the same time range.
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Uses numpy.iterp on values by default.
-
spectrum
¶ Returns the FFT spectrum of the signal.
-
frequencies
¶ Returns the FFT frequencies of the signal.
-
filter_frequencies
(freq_response, force_real=False)¶ Applies the given frequency response function to the signal. Optionally can attempt to force real results manually if the filter is only specified in positive frequencies.
-
class
-
class
pyrex.
EmptySignal
(times, value_type=<ValueTypes.undefined: 0>)¶ Bases:
pyrex.signals.Signal
Class for signal with no amplitude (all values = 0)
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Returns EmptySignal for new times.
-
-
class
pyrex.
FunctionSignal
(times, function, value_type=<ValueTypes.undefined: 0>)¶ Bases:
pyrex.signals.Signal
Class for signals generated by a function
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Leverages knowledge of the function to properly interpolate and extrapolate.
-
-
pyrex.
AskaryanSignal
¶ alias of
FastAskaryanSignal
-
class
pyrex.signals.
FastAskaryanSignal
(times, energy, theta, n=1.78, t0=0)¶ Bases:
pyrex.signals.Signal
Askaryan pulse binned to times from a particle shower with given energy (GeV) observed at angle theta (radians) from the shower axis. Optional parameters are the index of refraction n, and pulse offset to start time t0 (s). Returned signal values are electric fields (V/m).
Note that the amplitude of the pulse goes as 1/R, where R is the distance from source to observer. R is assumed to be 1 meter so that dividing by a different value produces the proper result.
-
vector_potential
¶ Recover the vector_potential from the electric field. Mostly just for testing purposes.
-
RAC
(time)¶ Calculates R * vector potential (A) at the Cherenkov angle in Vs at the given time (s).
-
charge_profile
(z, density=0.92, crit_energy=0.0786, rad_length=36.08)¶ Calculates the longitudinal charge profile in the EM shower at distance z (m) with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
max_length
(density=0.92, crit_energy=0.0786, rad_length=36.08)¶ Calculates the maximum length (m) of an EM shower with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
-
class
pyrex.
ThermalNoise
(times, f_band, f_amplitude=1, rms_voltage=None, temperature=None, resistance=None, n_freqs=0)¶ Bases:
pyrex.signals.FunctionSignal
Thermal Rayleigh noise in the frequency band f_band=[f_min,f_max] (Hz) at a given temperature (K) and resistance (ohms) or with a given RMS voltage (V). Optional parameters are f_amplitude (default 1) which can be a number or a function designating the amplitudes at each frequency, and n_freqs which is the number of frequencies to use (in f_band) for the calculation (default is based on the FFT bin size of the given times array). Returned signal values are voltages (V).
-
class
pyrex.
Antenna
(position, z_axis=(0, 0, 1), x_axis=(1, 0, 0), antenna_factor=1, efficiency=1, noisy=True, unique_noise_waveforms=10, freq_range=None, temperature=None, resistance=None, noise_rms=None)¶ Base class for an antenna with a given position (m), temperature (K), allowable frequency range (Hz), total resistance (ohm) used for Johnson noise, and whether or not to include noise in the antenna’s waveforms. Defines default trigger, frequency response, and signal reception functions that can be overwritten in base classes to customize the antenna.
-
set_orientation
(z_axis=(0, 0, 1), x_axis=(1, 0, 0))¶
-
is_hit
¶ Test for whether the antenna has been triggered.
-
is_hit_during
(times)¶ Test for whether the antenna has been triggered during the given times array.
-
clear
(reset_noise=False)¶ Reset the antenna to a state of having received no signals. Can optionally reset noise, which will reset the noise waveform so that a new signal arriving at the same time does not have the same noise.
-
waveforms
¶ Signal + noise (if noisy) at each triggered antenna hit.
-
all_waveforms
¶ Signal + noise (if noisy) at all antenna hits, even those that didn’t trigger.
-
full_waveform
(times)¶ Signal + noise (if noisy) for the given times array.
-
make_noise
(times)¶ Returns the noise signal generated by the antenna over the given array of times. Used to add noise to signal for production of the antenna’s waveforms.
-
trigger
(signal)¶ Function to determine whether or not the antenna is triggered by the given Signal object.
-
directional_gain
(theta, phi)¶ Function to calculate the directive electric field gain of the antenna at given angles theta (polar) and phi (azimuthal) relative to the antenna’s orientation.
-
polarization_gain
(polarization)¶ Function to calculate the electric field gain due to polarization for a given polarization direction.
-
response
(frequencies)¶ Function to return the frequency response of the antenna at the given frequencies (Hz). This function should return the response as imaginary numbers of the form A*exp(i*phi), where A is the amplitude response and phi is the phase shift.
-
receive
(signal, direction=None, polarization=None, force_real=False)¶ Process incoming signal according to the filter function and store it to the signals list. Optionally applies directional gain if direction is specified, applies polarization gain if polarization is specified, and forces any frequency response filters to return real signals if specified. Subclasses may extend this fuction, but should likely end with super().receive(signal).
-
-
class
pyrex.
DipoleAntenna
(name, position, center_frequency, bandwidth, resistance, orientation=(0, 0, 1), trigger_threshold=0, effective_height=None, noisy=True, unique_noise_waveforms=10)¶ Bases:
pyrex.antenna.Antenna
Antenna with a given name, position (m), center frequency (Hz), bandwidth (Hz), resistance (ohm), effective height (m), polarization direction, and trigger threshold (V).
-
trigger
(signal)¶ Trigger on the signal if the maximum signal value is above the given threshold.
-
response
(frequencies)¶ Butterworth filter response for the antenna’s frequency range.
-
directional_gain
(theta, phi)¶ Power gain of dipole antenna goes as sin(theta)^2, so electric field gain goes as sin(theta).
-
polarization_gain
(polarization)¶ Polarization gain is simply the dot product of the polarization with the antenna’s z-axis.
-
-
class
pyrex.
AntennaSystem
(antenna)¶ Base class for an antenna system consisting of an antenna and some front-end processes.
-
setup_antenna
(*args, **kwargs)¶ Setup the antenna by passing along its init arguments. This function can be overwritten if desired, just make sure to assign the self.antenna attribute in the function.
-
front_end
(signal)¶ This function should take the signal passed (from the antenna) and return the resulting signal after all processing by the antenna system’s front-end. By default it just returns the given signal.
-
is_hit
¶
-
is_hit_during
(times)¶
-
signals
¶
-
waveforms
¶
-
all_waveforms
¶
-
full_waveform
(times)¶
-
receive
(signal, direction=None, polarization=None, force_real=False)¶
-
clear
(reset_noise=False)¶ Reset the antenna system to a state of having received no signals. Can optionally reset noise, which will reset the noise waveform so that a new signal arriving at the same time does not have the same noise.
-
trigger
(signal)¶ Antenna system trigger. Should return True or False for whether the passed signal triggers the antenna system. By default just matches the antenna’s trigger.
-
-
class
pyrex.
Detector
(*args, **kwargs)¶ Class for automatically generating antenna positions based on geometry criteria. The set_positions method creates a list of antenna positions and the build_antennas method is responsible for actually placing antennas at the generated positions. Once antennas are placed, the class can be directly iterated over to iterate over the antennas (as if it were just a list of antennas itself).
-
test_antenna_positions
= True¶
-
set_positions
(*args, **kwargs)¶ Not implemented. Should generate positions for the antennas based on the given arguments and assign those positions to the antenna_positions attribute.
-
build_antennas
(*args, **kwargs)¶ Sets up antenna objects at the positions stored in the class. By default takes an antenna class and passes a position to the ‘position’ argument, followed by any other arguments to be passed to this class.
-
triggered
(*args, **kwargs)¶ Test for whether the detector is triggered based on the current state of the antennas.
-
clear
(reset_noise=False)¶ Convenience method for clearing all antennas in the detector. Can optionally reset noise, which will reset the noise waveforms so that new signals arriving at the same time do not have the same noise.
-
-
pyrex.
IceModel
¶ alias of
AntarcticIce
-
class
pyrex.ice_model.
ArasimIce
¶ Bases:
pyrex.ice_model.AntarcticIce
Class containing characteristics of ice at the south pole. In all cases, depth z is given with negative values in the ice and positive values above the ice. Ice model index is the same as used in the ARA collaboration’s AraSim package.
-
k
= 0.43¶
-
a
= 0.0132¶
-
n0
= 1.78¶
-
atten_depths
= [72.7412, 76.5697, 80.3982, 91.8836, 95.7121, 107.198, 118.683, 133.997, 153.139, 179.939, 206.738, 245.023, 298.622, 356.049, 405.819, 470.904, 516.845, 566.616, 616.386, 669.985, 727.412, 784.839, 838.438, 899.694, 949.464, 1003.06, 1060.49, 1121.75, 1179.17, 1236.6, 1297.86, 1347.63, 1405.05, 1466.31, 1516.08, 1565.85, 1611.79, 1657.73, 1699.85, 1745.79, 1791.73, 1833.84, 1883.61, 1929.56, 1990.81, 2052.07, 2109.49, 2170.75, 2232.01, 2304.75, 2362.17, 2431.09, 2496.17]¶
-
atten_lengths
= [1994.67, 1952, 1896, 1842.67, 1797.33, 1733.33, 1680, 1632, 1586.67, 1552, 1522.67, 1501.33, 1474.67, 1458.67, 1437.33, 1416, 1392, 1365.33, 1344, 1312, 1274.67, 1242.67, 1205.33, 1168, 1128, 1090.67, 1048, 1008, 965.333, 920, 874.667, 834.667, 797.333, 752, 714.667, 677.333, 648, 616, 589.333, 557.333, 530.667, 506.667, 477.333, 453.333, 418.667, 389.333, 362.667, 333.333, 309.333, 285.333, 264, 242.667, 221.333]¶
-
classmethod
attenuation_length
(z, f)¶ Returns the attenuation length at depth z (m) and frequency f (Hz). Attenuation length not actually frequency dependent; according to AraSim always uses the 300 MHz value. Supports passing a numpy array of depths and/or frequencies. If both are passed as arrays, a 2-D array is returned where each row is a single depth and each column is a single frequency.
-
-
pyrex.
prem_density
(r)¶ Returns the earth’s density (g/cm^3) for a given radius r (m). Calculated by the Preliminary Earth Model (PREM). Supports passing a list of radii.
-
pyrex.
slant_depth
(angle, depth, step=500)¶ Returns the material thickness (g/cm^2) for a chord cutting through earth at Nadir angle and starting at (positive-valued) depth (m). Can optionally specify the step size (m).
-
class
pyrex.
Particle
(vertex, direction, energy)¶ Class for storing particle attributes. Consists of a 3-D vertex (m), 3-D direction vector (automatically normalized), and an energy (GeV).
-
class
pyrex.
ShadowGenerator
(dx, dy, dz, energy)¶ Class to generate UHE neutrino vertices in (relatively) shallow detectors. Takes into accout Earth shadowing (sort of). energy should be either an energy in GeV or a function that returns an energy in GeV. Note that the x and y ranges in which particles are created are (-dx/2, dx/2) and (-dy/2, dy/2) while the z range is (-dz, 0).
-
create_particle
()¶ Creates a particle with random vertex in cube with a random direction.
-
-
pyrex.
RayTracer
¶ alias of
SpecializedRayTracer
-
class
pyrex.ray_tracing.
SpecializedRayTracer
(from_point, to_point, ice_model=<class 'pyrex.ice_model.AntarcticIce'>, dz=1)¶ Bases:
pyrex.ray_tracing.BasicRayTracer
Ray tracer specifically for ice model with index of refraction n(z) = n0 - k*exp(a*z). Calculations performed using true integral evaluation. Ice model must use methods inherited from pyrex.AntarcticIce
-
solution_class
¶ alias of
SpecializedRayTracePath
-
valid_ice_model
¶
-
z_uniform
¶
-
direct_r_max
¶
-
peak_angle
¶
-
-
pyrex.
RayTracePath
¶ alias of
SpecializedRayTracePath
-
class
pyrex.ray_tracing.
SpecializedRayTracePath
(parent_tracer, launch_angle, direct)¶ Bases:
pyrex.ray_tracing.BasicRayTracePath
Class for storing a single ray-trace solution betwen points, specifically for ice model with index of refraction n(z) = n0 - k*exp(a*z). Calculations performed using true integral evaluation (except attenuation). Ice model must use methods inherited from pyrex.AntarcticIce
-
uniformity_factor
= 0.99999¶
-
beta_tolerance
= 0.005¶
-
valid_ice_model
¶
-
z_uniform
¶
-
z_integral
(integrand, numerical=False, x_func=<function SpecializedRayTracePath.<lambda>>)¶ Function for integrating a given integrand along the depths of the path.
-
path_length
¶
-
tof
¶
-
attenuation
(f)¶ Returns the attenuation factor for a signal of frequency f (Hz) traveling along the path. Supports passing a list of frequencies.
-
coordinates
¶
-
-
class
pyrex.
EventKernel
(generator, antennas, ice_model=<class 'pyrex.ice_model.AntarcticIce'>, ray_tracer=<class 'pyrex.ray_tracing.SpecializedRayTracer'>, signal_times=array([-2.000e-08, -1.995e-08, -1.990e-08, ..., 7.985e-08, 7.990e-08, 7.995e-08]))¶ Kernel for generation of events with a given particle generator, list of antennas, and optionally a non-default ice_model.
-
event
()¶ Generate particle, propagate signal through ice to antennas, process signal at antennas, and return the original particle.
-
Submodules¶
pyrex.signals module¶
Module containing classes for digital signal processing
-
class
pyrex.signals.
Signal
(times, values, value_type=<ValueTypes.undefined: 0>)¶ Bases:
object
Base class for signals. Takes arrays of times and values (values array forced to size of times array by zero padding or slicing). Supports adding between signals with the same time values, resampling the signal, and calculating the signal’s envelope.
-
class
ValueTypes
¶ Bases:
enum.Enum
Enum containing possible types (units) for signal values.
-
undefined
= 0¶
-
voltage
= 1¶
-
field
= 2¶
-
power
= 3¶
-
-
dt
¶ Returns the spacing of the time array, or None if invalid.
-
envelope
¶ Calculates envelope of the signal by Hilbert transform.
-
resample
(n)¶ Resamples the signal into n points in the same time range.
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Uses numpy.iterp on values by default.
-
spectrum
¶ Returns the FFT spectrum of the signal.
-
frequencies
¶ Returns the FFT frequencies of the signal.
-
filter_frequencies
(freq_response, force_real=False)¶ Applies the given frequency response function to the signal. Optionally can attempt to force real results manually if the filter is only specified in positive frequencies.
-
class
-
class
pyrex.signals.
EmptySignal
(times, value_type=<ValueTypes.undefined: 0>)¶ Bases:
pyrex.signals.Signal
Class for signal with no amplitude (all values = 0)
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Returns EmptySignal for new times.
-
-
class
pyrex.signals.
FunctionSignal
(times, function, value_type=<ValueTypes.undefined: 0>)¶ Bases:
pyrex.signals.Signal
Class for signals generated by a function
-
with_times
(new_times)¶ Returns a signal object representing this signal with a different times array. Leverages knowledge of the function to properly interpolate and extrapolate.
-
-
class
pyrex.signals.
SlowAskaryanSignal
(times, energy, theta, n=1.78, t0=0)¶ Bases:
pyrex.signals.Signal
Askaryan pulse binned to times from a particle shower with given energy (GeV) observed at angle theta (radians) from the shower axis. Optional parameters are the index of refraction n, and pulse offset to start time t0 (s). Returned signal values are electric fields (V/m).
Note that the amplitude of the pulse goes as 1/R, where R is the distance from source to observer. R is assumed to be 1 meter so that dividing by a different value produces the proper result.
-
RAC
(time)¶ Calculates R * vector potential at the Cherenkov angle in Vs at the given time (s).
-
charge_profile
(z, density=0.92, crit_energy=0.0786, rad_length=36.08)¶ Calculates the longitudinal charge profile in the EM shower at distance z (m) with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
max_length
(density=0.92, crit_energy=0.0786, rad_length=36.08)¶ Calculates the maximum length (m) of an EM shower with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
-
class
pyrex.signals.
FastAskaryanSignal
(times, energy, theta, n=1.78, t0=0) Bases:
pyrex.signals.Signal
Askaryan pulse binned to times from a particle shower with given energy (GeV) observed at angle theta (radians) from the shower axis. Optional parameters are the index of refraction n, and pulse offset to start time t0 (s). Returned signal values are electric fields (V/m).
Note that the amplitude of the pulse goes as 1/R, where R is the distance from source to observer. R is assumed to be 1 meter so that dividing by a different value produces the proper result.
-
vector_potential
Recover the vector_potential from the electric field. Mostly just for testing purposes.
-
RAC
(time) Calculates R * vector potential (A) at the Cherenkov angle in Vs at the given time (s).
-
charge_profile
(z, density=0.92, crit_energy=0.0786, rad_length=36.08) Calculates the longitudinal charge profile in the EM shower at distance z (m) with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
max_length
(density=0.92, crit_energy=0.0786, rad_length=36.08) Calculates the maximum length (m) of an EM shower with parameters for the density (g/cm^3), critical energy (GeV), and electron radiation length (g/cm^2) in ice.
-
-
pyrex.signals.
AskaryanSignal
¶ alias of
FastAskaryanSignal
-
class
pyrex.signals.
GaussianNoise
(times, sigma)¶ Bases:
pyrex.signals.Signal
Gaussian noise signal with standard deviation sigma
-
class
pyrex.signals.
ThermalNoise
(times, f_band, f_amplitude=1, rms_voltage=None, temperature=None, resistance=None, n_freqs=0)¶ Bases:
pyrex.signals.FunctionSignal
Thermal Rayleigh noise in the frequency band f_band=[f_min,f_max] (Hz) at a given temperature (K) and resistance (ohms) or with a given RMS voltage (V). Optional parameters are f_amplitude (default 1) which can be a number or a function designating the amplitudes at each frequency, and n_freqs which is the number of frequencies to use (in f_band) for the calculation (default is based on the FFT bin size of the given times array). Returned signal values are voltages (V).
pyrex.antenna module¶
Module containing antenna class capable of receiving signals
-
class
pyrex.antenna.
Antenna
(position, z_axis=(0, 0, 1), x_axis=(1, 0, 0), antenna_factor=1, efficiency=1, noisy=True, unique_noise_waveforms=10, freq_range=None, temperature=None, resistance=None, noise_rms=None)¶ Bases:
object
Base class for an antenna with a given position (m), temperature (K), allowable frequency range (Hz), total resistance (ohm) used for Johnson noise, and whether or not to include noise in the antenna’s waveforms. Defines default trigger, frequency response, and signal reception functions that can be overwritten in base classes to customize the antenna.
-
set_orientation
(z_axis=(0, 0, 1), x_axis=(1, 0, 0))¶
-
is_hit
¶ Test for whether the antenna has been triggered.
-
is_hit_during
(times)¶ Test for whether the antenna has been triggered during the given times array.
-
clear
(reset_noise=False)¶ Reset the antenna to a state of having received no signals. Can optionally reset noise, which will reset the noise waveform so that a new signal arriving at the same time does not have the same noise.
-
waveforms
¶ Signal + noise (if noisy) at each triggered antenna hit.
-
all_waveforms
¶ Signal + noise (if noisy) at all antenna hits, even those that didn’t trigger.
-
full_waveform
(times)¶ Signal + noise (if noisy) for the given times array.
-
make_noise
(times)¶ Returns the noise signal generated by the antenna over the given array of times. Used to add noise to signal for production of the antenna’s waveforms.
-
trigger
(signal)¶ Function to determine whether or not the antenna is triggered by the given Signal object.
-
directional_gain
(theta, phi)¶ Function to calculate the directive electric field gain of the antenna at given angles theta (polar) and phi (azimuthal) relative to the antenna’s orientation.
-
polarization_gain
(polarization)¶ Function to calculate the electric field gain due to polarization for a given polarization direction.
-
response
(frequencies)¶ Function to return the frequency response of the antenna at the given frequencies (Hz). This function should return the response as imaginary numbers of the form A*exp(i*phi), where A is the amplitude response and phi is the phase shift.
-
receive
(signal, direction=None, polarization=None, force_real=False)¶ Process incoming signal according to the filter function and store it to the signals list. Optionally applies directional gain if direction is specified, applies polarization gain if polarization is specified, and forces any frequency response filters to return real signals if specified. Subclasses may extend this fuction, but should likely end with super().receive(signal).
-
-
class
pyrex.antenna.
DipoleAntenna
(name, position, center_frequency, bandwidth, resistance, orientation=(0, 0, 1), trigger_threshold=0, effective_height=None, noisy=True, unique_noise_waveforms=10)¶ Bases:
pyrex.antenna.Antenna
Antenna with a given name, position (m), center frequency (Hz), bandwidth (Hz), resistance (ohm), effective height (m), polarization direction, and trigger threshold (V).
-
trigger
(signal)¶ Trigger on the signal if the maximum signal value is above the given threshold.
-
response
(frequencies)¶ Butterworth filter response for the antenna’s frequency range.
-
directional_gain
(theta, phi)¶ Power gain of dipole antenna goes as sin(theta)^2, so electric field gain goes as sin(theta).
-
polarization_gain
(polarization)¶ Polarization gain is simply the dot product of the polarization with the antenna’s z-axis.
-
pyrex.detector module¶
Module containing higher-level AntennaSystem and Detector classes
-
class
pyrex.detector.
AntennaSystem
(antenna)¶ Bases:
object
Base class for an antenna system consisting of an antenna and some front-end processes.
-
setup_antenna
(*args, **kwargs)¶ Setup the antenna by passing along its init arguments. This function can be overwritten if desired, just make sure to assign the self.antenna attribute in the function.
-
front_end
(signal)¶ This function should take the signal passed (from the antenna) and return the resulting signal after all processing by the antenna system’s front-end. By default it just returns the given signal.
-
is_hit
¶
-
is_hit_during
(times)¶
-
signals
¶
-
waveforms
¶
-
all_waveforms
¶
-
full_waveform
(times)¶
-
receive
(signal, direction=None, polarization=None, force_real=False)¶
-
clear
(reset_noise=False)¶ Reset the antenna system to a state of having received no signals. Can optionally reset noise, which will reset the noise waveform so that a new signal arriving at the same time does not have the same noise.
-
trigger
(signal)¶ Antenna system trigger. Should return True or False for whether the passed signal triggers the antenna system. By default just matches the antenna’s trigger.
-
-
class
pyrex.detector.
Detector
(*args, **kwargs)¶ Bases:
object
Class for automatically generating antenna positions based on geometry criteria. The set_positions method creates a list of antenna positions and the build_antennas method is responsible for actually placing antennas at the generated positions. Once antennas are placed, the class can be directly iterated over to iterate over the antennas (as if it were just a list of antennas itself).
-
test_antenna_positions
= True¶
-
set_positions
(*args, **kwargs)¶ Not implemented. Should generate positions for the antennas based on the given arguments and assign those positions to the antenna_positions attribute.
-
build_antennas
(*args, **kwargs)¶ Sets up antenna objects at the positions stored in the class. By default takes an antenna class and passes a position to the ‘position’ argument, followed by any other arguments to be passed to this class.
-
triggered
(*args, **kwargs)¶ Test for whether the detector is triggered based on the current state of the antennas.
-
clear
(reset_noise=False)¶ Convenience method for clearing all antennas in the detector. Can optionally reset noise, which will reset the noise waveforms so that new signals arriving at the same time do not have the same noise.
-
pyrex.ice_model module¶
Module containing ice models. Ice model classes contains static and class methods for convenience. IceModel class is set to the preferred ice model.
-
class
pyrex.ice_model.
AntarcticIce
¶ Bases:
object
Class containing characteristics of ice at the south pole. In all cases, depth z is given with negative values in the ice and positive values above the ice. Index of refraction goes as n(z)=n0-k*exp(az).
-
k
= 0.43¶
-
a
= 0.0132¶
-
n0
= 1.78¶
-
thickness
= 2850¶
-
classmethod
gradient
(z)¶ Returns the gradient of the index of refraction at depth z (m).
-
classmethod
index
(z)¶ Returns the medium’s index of refraction, n, at depth z (m). Supports passing a numpy array of depths.
-
classmethod
depth_with_index
(n)¶ Returns the depth z (m) at which the medium has the given index of refraction (inverse of index function, assumes index function is monotonic so only one solution exists). Supports passing a numpy array of indices.
-
static
temperature
(z)¶ Returns the temperature (K) of the ice at depth z (m). Supports passing a numpy array of depths.
-
classmethod
attenuation_length
(z, f)¶ Returns the attenuation length at depth z (m) and frequency f (Hz). Supports passing a numpy array of depths and/or frequencies. If both are passed as arrays, a 2-D array is returned where each row is a single depth and each column is a single frequency.
-
-
class
pyrex.ice_model.
NewcombIce
¶ Bases:
pyrex.ice_model.AntarcticIce
Class inheriting from AntarcticIce, with new attenuation_length function based on Matt Newcomb’s fit (DOESN’T CURRENTLY WORK).
-
k
= 0.438¶
-
a
= 0.0132¶
-
n0
= 1.758¶
-
classmethod
attenuation_length
(z, f)¶ Returns the attenuation length at depth z (m) and frequency f (MHz) by Matt Newcomb’s fit (DOESN’T CURRENTLY WORK - USE BOGORODSKY).
-
-
class
pyrex.ice_model.
ArasimIce
Bases:
pyrex.ice_model.AntarcticIce
Class containing characteristics of ice at the south pole. In all cases, depth z is given with negative values in the ice and positive values above the ice. Ice model index is the same as used in the ARA collaboration’s AraSim package.
-
k
= 0.43
-
a
= 0.0132
-
n0
= 1.78
-
atten_depths
= [72.7412, 76.5697, 80.3982, 91.8836, 95.7121, 107.198, 118.683, 133.997, 153.139, 179.939, 206.738, 245.023, 298.622, 356.049, 405.819, 470.904, 516.845, 566.616, 616.386, 669.985, 727.412, 784.839, 838.438, 899.694, 949.464, 1003.06, 1060.49, 1121.75, 1179.17, 1236.6, 1297.86, 1347.63, 1405.05, 1466.31, 1516.08, 1565.85, 1611.79, 1657.73, 1699.85, 1745.79, 1791.73, 1833.84, 1883.61, 1929.56, 1990.81, 2052.07, 2109.49, 2170.75, 2232.01, 2304.75, 2362.17, 2431.09, 2496.17]
-
atten_lengths
= [1994.67, 1952, 1896, 1842.67, 1797.33, 1733.33, 1680, 1632, 1586.67, 1552, 1522.67, 1501.33, 1474.67, 1458.67, 1437.33, 1416, 1392, 1365.33, 1344, 1312, 1274.67, 1242.67, 1205.33, 1168, 1128, 1090.67, 1048, 1008, 965.333, 920, 874.667, 834.667, 797.333, 752, 714.667, 677.333, 648, 616, 589.333, 557.333, 530.667, 506.667, 477.333, 453.333, 418.667, 389.333, 362.667, 333.333, 309.333, 285.333, 264, 242.667, 221.333]
-
classmethod
attenuation_length
(z, f) Returns the attenuation length at depth z (m) and frequency f (Hz). Attenuation length not actually frequency dependent; according to AraSim always uses the 300 MHz value. Supports passing a numpy array of depths and/or frequencies. If both are passed as arrays, a 2-D array is returned where each row is a single depth and each column is a single frequency.
-
-
pyrex.ice_model.
IceModel
¶ alias of
AntarcticIce
pyrex.earth_model module¶
Module containing earth model. Uses PREM for density as a function of radius and a simple integrator for calculation of the slant depth as a function of nadir angle.
-
pyrex.earth_model.
prem_density
(r)¶ Returns the earth’s density (g/cm^3) for a given radius r (m). Calculated by the Preliminary Earth Model (PREM). Supports passing a list of radii.
-
pyrex.earth_model.
slant_depth
(angle, depth, step=500)¶ Returns the material thickness (g/cm^2) for a chord cutting through earth at Nadir angle and starting at (positive-valued) depth (m). Can optionally specify the step size (m).
pyrex.particle module¶
Module for particles (namely neutrinos) and neutrino interactions in the ice. Interactions include Earth shadowing (absorption) effect.
-
class
pyrex.particle.
NeutrinoInteraction
(c, p)¶ Bases:
object
Class for neutrino interaction attributes.
-
cross_section
(E)¶ Return the cross section (cm^2) at a given energy E (GeV).
-
interaction_length
(E)¶ Return the interaction length (cm) in water equivalent at a given energy E (GeV).
-
-
class
pyrex.particle.
Particle
(vertex, direction, energy)¶ Bases:
object
Class for storing particle attributes. Consists of a 3-D vertex (m), 3-D direction vector (automatically normalized), and an energy (GeV).
-
pyrex.particle.
random_direction
()¶ Generate an arbitrary 3D unit vector.
-
class
pyrex.particle.
ShadowGenerator
(dx, dy, dz, energy)¶ Bases:
object
Class to generate UHE neutrino vertices in (relatively) shallow detectors. Takes into accout Earth shadowing (sort of). energy should be either an energy in GeV or a function that returns an energy in GeV. Note that the x and y ranges in which particles are created are (-dx/2, dx/2) and (-dy/2, dy/2) while the z range is (-dz, 0).
-
create_particle
()¶ Creates a particle with random vertex in cube with a random direction.
-
-
class
pyrex.particle.
ListGenerator
(particles, loop=True)¶ Bases:
object
Class to generate neutrinos by simply pulling them from a list of Particle objects. By default returns to the start of the list once the end is reached, but can optionally fail after reaching the list’s end.
-
create_particle
()¶ Pulls next particle from the list.
-
-
class
pyrex.particle.
FileGenerator
(files)¶ Bases:
object
Class to generate neutrinos by pulling their vertex, direction, and energy from a (list of) .npz file(s). Each file must have three arrays, containing the vertices, directions, and energies respectively so the first particle will have properties given by the first elements of these three arrays. Tries to smartly figure out which array is which based on their names, but if the arrays are unnamed, assumes they are in the order used above.
-
create_particle
()¶ Pulls the next particle from the file(s).
-
pyrex.ray_tracing module¶
Module containing class for ray tracing through the ice.
-
class
pyrex.ray_tracing.
BasicRayTracePath
(parent_tracer, launch_angle, direct)¶ Bases:
pyrex.internal_functions.LazyMutableClass
Class for storing a single ray-trace solution betwen points. Calculations preformed by integrating z-steps of size dz. Most properties lazily evaluated to save on re-computation time.
-
z_turn_proximity
¶ Parameter for how closely path approaches z_turn. Necessary to avoid diverging integrals.
-
z0
¶ Depth of the launching point.
-
z1
¶ Depth of the receiving point.
-
n0
¶
-
rho
¶
-
phi
¶
-
beta
¶
-
z_turn
¶
-
emitted_direction
¶
-
received_direction
¶
-
theta
(z)¶ Polar angle of the ray at given depth or array of depths.
-
z_integral
(integrand)¶ Returns the integral of the integrand (a function of z) along the path.
-
path_length
¶
-
tof
¶
-
fresnel
¶
-
attenuation
(f)¶ Returns the attenuation factor for a signal of frequency f (Hz) traveling along the path. Supports passing a list of frequencies.
-
propagate
(signal)¶ Applies attenuation to the signal along the path.
-
coordinates
¶
-
-
class
pyrex.ray_tracing.
SpecializedRayTracePath
(parent_tracer, launch_angle, direct) Bases:
pyrex.ray_tracing.BasicRayTracePath
Class for storing a single ray-trace solution betwen points, specifically for ice model with index of refraction n(z) = n0 - k*exp(a*z). Calculations performed using true integral evaluation (except attenuation). Ice model must use methods inherited from pyrex.AntarcticIce
-
uniformity_factor
= 0.99999
-
beta_tolerance
= 0.005
-
valid_ice_model
-
z_uniform
-
z_integral
(integrand, numerical=False, x_func=<function SpecializedRayTracePath.<lambda>>) Function for integrating a given integrand along the depths of the path.
-
path_length
-
tof
-
attenuation
(f) Returns the attenuation factor for a signal of frequency f (Hz) traveling along the path. Supports passing a list of frequencies.
-
coordinates
-
-
class
pyrex.ray_tracing.
BasicRayTracer
(from_point, to_point, ice_model=<class 'pyrex.ice_model.AntarcticIce'>, dz=1)¶ Bases:
pyrex.internal_functions.LazyMutableClass
Class for proper ray tracing. Calculations performed by integrating z-steps with size dz. Most properties lazily evaluated to save on re-computation time.
-
solution_class
¶ alias of
BasicRayTracePath
-
z_turn_proximity
¶ Parameter for how closely path approaches z_turn. Necessary to avoid diverging integrals.
-
z0
¶ Depth of lower point. Ray tracing performed as if launching from lower point to higher point.
-
z1
¶ Depth of higher point. Ray tracing performed as if launching from lower point to higher point.
-
n0
¶
-
rho
¶
-
max_angle
¶
-
peak_angle
¶
-
direct_r_max
¶
-
indirect_r_max
¶
-
exists
¶
-
expected_solutions
¶
-
solutions
¶
-
direct_angle
¶
-
indirect_angle_1
¶
-
indirect_angle_2
¶
-
static
angle_search
(true_r, r_function, min_angle, max_angle, tolerance=1e-12, max_iterations=100)¶ Root-finding algorithm.
-
-
class
pyrex.ray_tracing.
SpecializedRayTracer
(from_point, to_point, ice_model=<class 'pyrex.ice_model.AntarcticIce'>, dz=1) Bases:
pyrex.ray_tracing.BasicRayTracer
Ray tracer specifically for ice model with index of refraction n(z) = n0 - k*exp(a*z). Calculations performed using true integral evaluation. Ice model must use methods inherited from pyrex.AntarcticIce
-
solution_class
alias of
SpecializedRayTracePath
-
valid_ice_model
-
z_uniform
-
direct_r_max
-
peak_angle
-
-
pyrex.ray_tracing.
RayTracer
¶ alias of
SpecializedRayTracer
-
pyrex.ray_tracing.
RayTracePath
¶ alias of
SpecializedRayTracePath
-
class
pyrex.ray_tracing.
PathFinder
(ice_model, from_point, to_point)¶ Bases:
object
Class for pseudo ray tracing. Just uses straight-line paths.
-
exists
¶ Boolean of whether path exists based on basic total internal reflection calculation.
-
emitted_ray
¶ Direction in which ray is emitted.
-
received_ray
¶ Direction from which ray is received.
-
path_length
¶ Length of the path (m).
-
tof
¶ Time of flight (s) for a particle along the path. Calculated using default values of self.time_of_flight()
-
time_of_flight
(n_steps=100)¶ Time of flight (s) for a particle along the path.
-
attenuation
(f, n_steps=100)¶ Returns the attenuation factor for a signal of frequency f (Hz) traveling along the path. Supports passing a list of frequencies.
-
propagate
(signal)¶ Applies attenuation to the signal along the path.
-
-
class
pyrex.ray_tracing.
ReflectedPathFinder
(ice_model, from_point, to_point, reflection_depth=0)¶ Bases:
object
Class for pseudo ray tracing of ray reflected off ice surface. Just uses straight-line paths.
-
get_bounce_point
(reflection_depth=0)¶ Calculation of point at which signal is reflected by the ice surface (z=0).
-
exists
¶ Boolean of whether path exists based on whether its sub-paths exist and whether it could reflect off the ice surface.
-
emitted_ray
¶ Direction in which ray is emitted.
-
received_ray
¶ Direction from which ray is received.
-
path_length
¶ Length of the path (m).
-
tof
¶ Time of flight (s) for a particle along the path. Calculated using default values of self.time_of_flight()
-
time_of_flight
(n_steps=100)¶ Time of flight (s) for a particle along the path.
-
attenuation
(f, n_steps=100)¶ Returns the attenuation factor for a signal of frequency f (Hz) traveling along the path. Supports passing a list of frequencies.
-
propagate
(signal)¶ Applies attenuation to the signal along the path.
-
pyrex.kernel module¶
Module for the simulation kernel. Includes neutrino generation, ray tracking (no raytracing yet), and hit generation.
-
class
pyrex.kernel.
EventKernel
(generator, antennas, ice_model=<class 'pyrex.ice_model.AntarcticIce'>, ray_tracer=<class 'pyrex.ray_tracing.SpecializedRayTracer'>, signal_times=array([-2.000e-08, -1.995e-08, -1.990e-08, ..., 7.985e-08, 7.990e-08, 7.995e-08]))¶ Bases:
object
Kernel for generation of events with a given particle generator, list of antennas, and optionally a non-default ice_model.
-
event
()¶ Generate particle, propagate signal through ice to antennas, process signal at antennas, and return the original particle.
-
pyrex.internal_functions module¶
Helper functions for use in PyREx modules.
-
pyrex.internal_functions.
normalize
(vector)¶ Returns the normalized form of the given vector.
-
pyrex.internal_functions.
flatten
(iterator, dont_flatten=())¶ Flattens all iterable elements in the given iterator recursively and returns the resulting flat iterator. Can optionally be passed a list of classes to avoid flattening. Will not flatten strings or bytes due to recursion errors.
-
pyrex.internal_functions.
mirror_func
(match_func, run_func, self=None)¶ Returns a function which operates like run_func, but has all the attributes of match_func. If self argument is not None, it will be passed as the first argument to run_func.
-
pyrex.internal_functions.
lazy_property
(fn)¶ Decorator that makes a property lazily evaluated.
-
class
pyrex.internal_functions.
LazyMutableClass
(static_attributes=None)¶ Bases:
object
Class whose properties can be lazily evaluated by using lazy_property decorator, but will re-evaluate lazy properties if any of its specified static_attributes change. By default, static_attributes is set to all attributes of the class at the time of the init call.
PyREx Custom Subpackage¶
Note that more modules may be available as plug-ins, see Custom Sub-Package.
pyrex.custom.pyspice module¶
Module containing setup and wrappers for PySpice module into PyREx
pyrex.custom.irex package¶
Customizations of pyrex package specific to IREX (IceCube Radio Extension)
pyrex.custom.irex.antenna module¶
Module containing customized antenna classes for IREX
-
class
pyrex.custom.irex.antenna.
IREXAntenna
(position, center_frequency, bandwidth, resistance, orientation=(0, 0, 1), effective_height=None, noisy=True, unique_noise_waveforms=10)¶ Bases:
pyrex.antenna.Antenna
Antenna to be used in IREX. Has a position (m), center frequency (Hz), bandwidth (Hz), resistance (ohm), effective height (m), and polarization direction.
-
response
(frequencies)¶ Butterworth filter response for the antenna’s frequency range.
-
directional_gain
(theta, phi)¶ Power gain of dipole antenna goes as sin(theta)^2, so electric field gain goes as sin(theta).
-
polarization_gain
(polarization)¶ Polarization gain is simply the dot product of the polarization with the antenna’s z-axis.
-
-
class
pyrex.custom.irex.antenna.
IREXAntennaSystem
(name, position, trigger_threshold, time_over_threshold=0, orientation=(0, 0, 1), amplification=1, amplifier_clipping=3, noisy=True, unique_noise_waveforms=10, envelope_method='analytic')¶ Bases:
pyrex.detector.AntennaSystem
IREX antenna system consisting of dipole antenna, low-noise amplifier, optional bandpass filter, and envelope circuit.
-
setup_antenna
(center_frequency=250000000.0, bandwidth=300000000.0, resistance=100, orientation=(0, 0, 1), effective_height=None, noisy=True, unique_noise_waveforms=10)¶ Sets attributes of the antenna including center frequency (Hz), bandwidth (Hz), resistance (ohms), orientation, and effective height (m).
-
make_envelope
(signal)¶ Return the signal envelope based on the antenna’s envelope_method.
-
front_end
(signal)¶ Apply the front-end processing of the antenna signal, including amplification, clipping, and envelope processing.
-
all_waveforms
¶
-
full_waveform
(times)¶
-
trigger
(signal)¶
-
pyrex.custom.irex.detector module¶
Module containing customized detector geometry classes for IREX
-
class
pyrex.custom.irex.detector.
IREXString
(x, y, antennas_per_string=2, antenna_separation=50, lowest_antenna=-100)¶ Bases:
pyrex.detector.Detector
String of IREXAntennas. Sets positions of antennas on string based on the given arguments. Sets build_antennas method for setting antenna characteristics.
-
set_positions
(x, y, antennas_per_string=2, antenna_separation=50, lowest_antenna=-100)¶ Generates antenna positions along the string.
-
build_antennas
(trigger_threshold, time_over_threshold=0, amplification=1, naming_scheme=<function IREXString.<lambda>>, orientation_scheme=<function IREXString.<lambda>>, noisy=True, unique_noise_waveforms=10, envelope_method='analytic')¶ Sets up IREXAntennaSystems at the positions stored in the class. Takes as arguments the trigger threshold, optional time over threshold, and whether to add noise to the waveforms. Other optional arguments include a naming scheme and orientation scheme which are functions taking the antenna index i and the antenna object. The naming scheme should return the name and the orientation scheme should return the orientation z-axis and x-axis of the antenna.
-
triggered
(antenna_requirement=1)¶ Test whether the number of hit antennas meets the given antenna trigger requirement.
-
-
class
pyrex.custom.irex.detector.
RegularStation
(x, y, strings_per_station=4, station_diameter=50, string_type=<class 'pyrex.custom.irex.detector.IREXString'>, **string_kwargs)¶ Bases:
pyrex.detector.Detector
Station geometry with a number of strings evenly spaced radially around the station center. Supports any string type and passes extra keyword arguments on to the string class.
-
set_positions
(x, y, strings_per_station=4, station_diameter=50, string_type=<class 'pyrex.custom.irex.detector.IREXString'>, **string_kwargs)¶ Generates string positions around the station.
-
triggered
(antenna_requirement=1, string_requirement=1)¶ Test whether the number of hit antennas meets the given antenna and string trigger requirements.
-
-
class
pyrex.custom.irex.detector.
CoxeterStation
(x, y, strings_per_station=4, station_diameter=50, string_type=<class 'pyrex.custom.irex.detector.IREXString'>, **string_kwargs)¶ Bases:
pyrex.detector.Detector
Station geometry with one string at the station center and the rest of the strings evenly spaced radially around the station center. Supports any string type and passes extra keyword arguments on to the string class.
-
set_positions
(x, y, strings_per_station=4, station_diameter=50, string_type=<class 'pyrex.custom.irex.detector.IREXString'>, **string_kwargs)¶ Generates string positions around the station.
-
triggered
(antenna_requirement=1, string_requirement=1)¶ Test whether the number of hit antennas meets the given antenna and string trigger requirements.
-
-
class
pyrex.custom.irex.detector.
StationGrid
(stations=1, station_separation=500, station_type=<class 'pyrex.custom.irex.detector.IREXString'>, **station_kwargs)¶ Bases:
pyrex.detector.Detector
Rectangular grid of stations or strings, in a square layout if possible, separated by the given distance. Supports any station or string type and passes extra keyword arguments on to the station or string class.
-
set_positions
(stations=1, station_separation=500, station_type=<class 'pyrex.custom.irex.detector.IREXString'>, **station_kwargs)¶ Generates rectangular grid of stations.
-
triggered
(station_requirement=1, **station_trigger_kwargs)¶ Test whether the number of hit stations meets the given station trigger requirement.
-
pyrex.custom.irex.frontends module¶
Module containing IREX front-end circuit models
-
pyrex.custom.irex.frontends.
basic_envelope_model
(signal, cap=2e-11, res=500)¶ Model of a basic diode-capacitor-resistor envelope circuit. Takes a signal object as the input voltage and returns the output voltage signal object.
-
pyrex.custom.irex.frontends.
bridge_rectifier_envelope_model
(signal, cap=2e-11, res=500)¶ Model of a diode bridge rectifier envelope circuit. Takes a signal object as the input voltage and returns the output voltage signal object.
pyrex.custom.irex.reconstruction module¶
Module containing reconstruction methods for IREX
-
pyrex.custom.irex.reconstruction.
quick_vertex_reconstruction
(detector, threshold=None, get_waveform=<function <lambda>>)¶
-
pyrex.custom.irex.reconstruction.
full_vertex_reconstruction
(detector, threshold=None, get_waveform=<function <lambda>>)¶
-
pyrex.custom.irex.reconstruction.
get_xcorr_times
(waveforms)¶
-
pyrex.custom.irex.reconstruction.
minimizer_vertex_reconstruction
(positions, times, guess=None)¶
-
pyrex.custom.irex.reconstruction.
least_squares
(vertex, positions, times, method='trace')¶
-
pyrex.custom.irex.reconstruction.
bancroft_vertex
(positions, times, velocity=170940170.94017094)¶
-
pyrex.custom.irex.reconstruction.
bancroft_scan_vertex
(positions, times, velocity=170940170.94017094)¶


|
cds
1.2.0
|
Lazy ordered single-linked list (template specialization for gc::nogc) More...
#include <cds/container/lazy_list_nogc.h>
Public Types | |
| typedef T | value_type |
| Type of value stored in the list. | |
| typedef base_class::gc | gc |
| Garbage collector used. | |
| typedef base_class::back_off | back_off |
| Back-off strategy used. | |
| typedef options::allocator_type | allocator_type |
| Allocator type used for allocate/deallocate the nodes. | |
| typedef base_class::item_counter | item_counter |
| Item counting policy used. | |
| typedef options::key_comparator | key_comparator |
| key comparision functor | |
| typedef base_class::memory_model | memory_model |
| Memory ordering. See cds::opt::memory_model option. | |
| typedef iterator_type< false > | iterator |
| Returns a forward iterator addressing the first element in a list. | |
| typedef iterator_type< true > | const_iterator |
| Const forward iterator. |
Public Member Functions | |
| iterator | begin () |
| Returns a forward iterator addressing the first element in a list. | |
| iterator | end () |
| Returns an iterator that addresses the location succeeding the last element in a list. | |
| const_iterator | begin () const |
| Returns a forward const iterator addressing the first element in a list. | |
| const_iterator | end () const |
| Returns an const iterator that addresses the location succeeding the last element in a list. | |
| LazyList () | |
| Default constructor. | |
| ~LazyList () | |
| List desctructor. | |
| template<typename Q > | |
| iterator | insert (const Q &val) |
| Inserts new node. | |
| template<typename Q > | |
| std::pair< iterator, bool > | ensure (const Q &val) |
Ensures that the item val exists in the list. | |
| template<typename Q > | |
| iterator | find (const Q &key) |
Find the key val . | |
| bool | empty () const |
| Check if the list is empty. | |
| size_t | size () const |
| Returns list's item count. | |
| void | clear () |
| Clears the list. |
Additional Inherited Members | |
| Protected Types inherited from cds::intrusive::LazyList< gc::nogc, T, Traits > | |
| typedef T | value_type |
| type of value stored in the list | |
| typedef Traits | options |
| Traits template parameter. | |
| typedef options::hook | hook |
| hook type | |
| typedef hook::node_type | node_type |
| node type | |
| typedef implementation_defined | key_comparator |
| key comparision functor based on opt::compare and opt::less option setter. | |
| typedef options::disposer | disposer |
| disposer used | |
|
typedef get_node_traits < value_type, node_type, hook > ::type | node_traits |
| node traits | |
|
typedef lazy_list::get_link_checker < node_type, options::link_checker >::type | link_checker |
| link checker | |
| typedef gc::nogc | gc |
| Garbage collector. | |
| typedef options::back_off | back_off |
| back-off strategy (not used) | |
| typedef options::item_counter | item_counter |
| Item counting policy used. | |
| typedef options::memory_model | memory_model |
| C++ memory ordering (see lazy_list::type_traits::memory_model) | |
| typedef iterator_type< false > | iterator |
| Forward iterator. | |
| typedef iterator_type< true > | const_iterator |
| Const forward iterator. | |
| typedef node_type * | auxiliary_head |
| Auxiliary head type (for split-list support) | |
| Protected Member Functions inherited from cds::intrusive::LazyList< gc::nogc, T, Traits > | |
| bool | insert (value_type &val) |
| Inserts new node. | |
| template<typename Func > | |
| std::pair< bool, bool > | ensure (value_type &val, Func func) |
Ensures that the item exists in the list. | |
| template<typename Q , typename Func > | |
| bool | find (Q &val, Func f) |
Find the key val . | |
| template<typename Disposer > | |
| void | clear (Disposer disp) |
| Clears the list. |
Lazy ordered single-linked list (template specialization for gc::nogc)
This specialization is intended for so-called persistent usage when no item reclamation may be performed. The class does not support deleting of list item.
See LazyList for description of template parameters.
The interface of the specialization is a little different.
| typedef iterator_type<true> cds::container::LazyList< gc::nogc, T, Traits >::const_iterator |
Const forward iterator.
For iterator's features and requirements see iterator
| typedef iterator_type<false> cds::container::LazyList< gc::nogc, T, Traits >::iterator |
|
inline |
Default constructor.
Initialize empty list
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
List desctructor.
Clears the list
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
Returns a forward iterator addressing the first element in a list.
For empty list
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
Clears the list.
Post-condition: the list is empty
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
Returns an iterator that addresses the location succeeding the last element in a list.
Do not use the value returned by end
function to access any item.
The returned value can be used only to control reaching the end of the list. For empty list
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
Ensures that the item val
exists in the list.
The operation inserts new item if the key val
is not found in the list. Otherwise, the function returns an iterator that points to item found.
Returns std::pair<iterator, bool>
where first
is an iterator pointing to item found or inserted, second
is true if new item has been added or false
if the item already is in the list.
|
inline |
Find the key val
.
The function searches the item with key equal to val
and returns an iterator pointed to item found if the key is found, and end() otherwise
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.
|
inline |
Inserts new node.
The function inserts val
in the list if the list does not contain an item with key equal to val
.
Return an iterator pointing to inserted item if success end() otherwise
|
inline |
Returns list's item count.
The value returned depends on opt::item_counter option. For atomicity::empty_item_counter, this function always returns 0.
Warning: even if you use real item counter and it returns 0, this fact is not mean that the list is empty. To check list emptyness use empty() method.
Reimplemented from cds::intrusive::LazyList< gc::nogc, T, Traits >.


Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).
The addition operator produces the sum of numeric operands or string concatenation.
Operator: x + y
// Number + Number -> addition 1 + 2 // 3 // Boolean + Number -> addition true + 1 // 2 // Boolean + Boolean -> addition false + false // 0 // Number + String -> concatenation 5 + "foo" // "5foo" // String + Boolean -> concatenation "foo" + false // "foofalse" // String + String -> concatenation "foo" + "bar" // "foobar"
The subtraction operator subtracts the two operands, producing their difference.
Operator: x - y
5 - 3 // 2 3 - 5 // -2 "foo" - 3 // NaN
The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.
Operator: x / y
1 / 2 // returns 0.5 in JavaScript 1 / 2 // returns 0 in Java // (neither number is explicitly a floating point number) 1.0 / 2.0 // returns 0.5 in both JavaScript and Java 2.0 / 0 // returns Infinity in JavaScript 2.0 / 0.0 // returns Infinity too 2.0 / -0.0 // returns -Infinity in JavaScript
The multiplication operator produces the product of the operands.
Operator: x * y
2 * 2 // 4 -2 * 2 // -4 Infinity * 0 // NaN Infinity * Infinity // Infinity "foo" * 2 // NaN
The remainder operator returns the first operand modulo the second operand, that is, var1
modulo var2
, in the preceding statement, where var1
and var2
are variables. The modulo function is the integer remainder of dividing var1
by var2
. There is a proposal to get an actual modulo operator in a future version of ECMAScript.
Operator: var1 % var2
12 % 5 // 2 -1 % 2 // -1 NaN % 2 // NaN 1 % 2 // 1 2 % 3 // 2 -4 % 2 // -0
[ECMAScript 2016 (ES7) proposal]
The exponentiation operator returns the result of raising first operand to the power second operand. that is, var1
var2
, in the preceding statement, where var1
and var2
are variables. Exponentiation operator is right associative. a ** b ** c
is equal to a ** (b ** c)
.
Operator: var1 ** var2
In most languages like PHP and Python and others that have an exponentiation operator (typically ^ or **), the exponentiation operator is defined to have a higher precedence than other unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash or in the current ES7 exponentiation operator draft spec, the ** operator is defined to have a lower precedence than unary operators.
-2 ** 2 // equals 4 in ES7 or in Bash, equals -4 in other languages.
2 ** 3 // 8 3 ** 2 // 9 3 ** 2.5 // 15.588457268119896 10 ** -1 // 0.1 NaN ** 2 // NaN 2 ** 3 ** 2 // 512 2 ** (3 ** 2) // 512 (2 ** 3) ** 2 // 64
The increment operator increments (adds one to) its operand and returns a value.
Operator: x++ or ++x
// Postfix var x = 3; y = x++; // y = 3, x = 4 // Prefix var a = 2; b = ++a; // a = 3, b = 3
The decrement operator decrements (subtracts one from) its operand and returns a value.
Operator: x-- or --x
// Postfix var x = 3; y = x--; // y = 3, x = 2 // Prefix var a = 2; b = --a; // a = 1, b = 1
The unary negation operator precedes its operand and negates it.
Operator: -x
var x = 3; y = -x; // y = -3, x = 3
The unary plus operator precedes its operand and evaluates to its operand but attempts to converts it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true
, false
, and null
. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to NaN.
Operator: +x
+3 // 3 +"3" // 3 +true // 1 +false // 0 +null // 0
Created by Mozilla Contributors, license: CC-BY-SA 2.5


Linux is a family of open-source Unix-like operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991, by Linus Torvalds. Linux is typically packaged in a Linux distribution.

A programming language is a formal language comprising a set of strings that produce various kinds of machine code output. Programming languages are one kind of computer language, and are used in computer programming to implement algorithms.


 I am Subhendu Dash. I was born in Odisha and brought up in Bangalore. I am currently persuing BTech Electrical Engineering in VIT Chennai.
I love to explore different interesting and trending topics in Internet. I love to watch different web-series and movies.
I am proficient in HTML, CSS and fundamentals of JavaScript. I am currently strengthening in JavaScript for the front-end development, also its frameworks.
Recently I have started with the fundamentals of ML using Python packages like Scikit-learn and Tensorflow. Also interested in the field of Computer Vision.