Here I present several projects that I have been working and learning through this year.
My history with programming comes from my college background as Mechatronic Engineer, where I took courses as "Digital Systems" where I began with low level languages as "Assembler" and made some projects with greater electronic presence and understanding the basics and origins of computers. I also attended "Object Oriented Programming Language" where I learned C++ with the Visual Studio IDE and made interesting projects with basic hardware meanwhile learning data structure, algorithms and good practices in programming.
After that I left the programming part of my carreer relegated to dedicate myself to diferent Projects. But during 2020 year I rediscovered programming and the multitude of possibilities to grow in this field. Additionally I have a better Self-knowledge and believe I have aptitudes to be a good programmer. Overall I'm a hard working person, autodidact and constantly looking for improving in my job, learning and searching new ways to do or automate the work is part of me. I also like to integrate the Agile methodology in my work and my life where planning and testing is a dynamic labor. I'm looking for a team or company to work together, Thanks for reading!
View ResumeThis web application is developed using React Framework and its diferents capabilities as Controlled Forms, Uncontrolled Forms, Redux Forms, React Routers and several types of Components.
This is a Customer Managment Aplication, developed using technologies as Laravel, PHP, mySQL and BootStrap4.
E-commerce website developed using Wordpress and Woocommerce. Is fully responsive and use a customized theme wrote in php, html & css. Actually sportech is in operation being capable of receives pays by card, calculate shipping cost, and process orders with security for clients.
This site is devepeloped using several features that Bootstrap4 provides to make usefull webpages and saving tons of working hours. Some features presented are: Navbar, Modals, Carousel, Forms, Breadcrumbs, Accordion. The page is complemented and customized using Sass and Jquery for some aditional capabilities.
Website with interactive, responsive and fluid navigation. Uses animations in javascript, "Reveal on Scroll" for sections, the BEM methodology in CSS and the service "netlify" as secure server to storage passwords for "Area de clientes".
This is a responsive web aplication which allow to make orders of products quickly and without complications of payments methods. An easy solutions for E-commerce on early stages. For bussiness who want to show his products and the value offert.
This web page use javascript to toggle between dark and light themes, which are designed with "undraw" illustrations and "heropatters" backgrounds.
This is an interactive project which use javascript DOM manipulation to update visualization of the board. Designed with drag and drop functionality. Also use LocalStorage to save user data.
This project use Nasa APOD API to make a gallery of 5 different photos each time you click in "Cargar más", where it shows the title, descripction, author and date. Also has the "favoritos" function where it use LocalStorage to saved the data.
An stylish webpage for a Personal description. With Animated Menu which shows an overlay with colorfull slides and links to all the section of this website.
This project uses only HTML and CSS3 with the librarys "Animated on Scroll" and 'Tailwindcss" which provide diferent tools.
This is the popular game Ping Pong, it's made using the HTML5 Canvas element and javascript to draw the graphics and create the animations. The user can move the paddle with the mouse and enjoy a match with a computer equipped with a simple AI.
This web app is a math game which challengue the user with a list of math statements to be solved as fast as posible to get a better score. Then it shows via javascript DOM manipulation 4 pages: Countdown, Game, Score and Splash Pages wich make easy the interaction.
This project is about a classic childhood game but aumented to five options. The logic is simple and is developed in javascript with the use of switch-case selectors and arrays. DOM manipulation and some animations are part of the game.
A usefull Countdown with customizable date that use javascript time methods and LocalStorage to save user Countdown until he decide to reset it. Additionally, it has a responsive video in the background.
This is the classic but inevitable user Form Validation. It ask for several data and use HTML5 Validation to make this job easy. Also complementing this work with Constraint validation API and customized error messages.
Here is used the HTML5 audio element with a stylish user interface to show songs image, title, artist, progress and controls. All the functionality is implemented with event listeners and javascript functions.
Here is used the HTML5 Video element and it's interactive controls: play/pause, volume, speed, fullscreen and progress bar which are manipulated with several functions in javascript.
This web app use a simple but usefull interface. It works with the Html5 video element and the Picture-in-Picture javascript API. The aplication allow the user work with a second mini window which can be located in any place in the screen.
This web app gets quotes from the "Forismatic API". Working with asincronous function and using the fetch API in javascript.


 I can’t even think of an analogy for adding a subset of a website to the chrome of software made for accessing the same complete websites as its primary functionality.
A car with another smaller car inside it that doesn’t go as fast or as far?
The list of features in the screenshot — share easily, connect with friends, search faster, keep up on news — are all things any browser can do today by simply visiting websites. It’s impossible to tell what those avatars down the left hand edge represent but why would you ever want a row of faces constantly staring back at you while you’re browsing?
Shit like this seems to be a momentum gaining trend of social media being treated as though it has inherent value. The “features” RockMelt adds to Chrome may not be useful and they may actually detract from the web browsing experience but because it’s social media it’s considered valuable.
Via Daring Fireball.


Choose a username and password. Because of in-game limitations, the usernames can be at most 15 characters, and may only contain alphanumeric characters. Your username will be shown to other players.
You should choose a password that you're not using in any other service - you're dealing with the hacker community, after all. Note that the passwords cannot be reset - make sure you don't forget it.
Set a new message here.
You are viewing ?'s profile.
You are logged in as ?. Not you? Log out.
The event has ended. Servers will remain operational until April 23, 15:30 UTC, so the game will remain playable during that period - however, the leaderboard will no longer update. After server shutdown, the project's source code will be released on https://github.com/zzazzdzz/fools2018.
Play online in your modern HTML5 compatible browser without any further setup, or use a desktop app with the BGB emulator. Click here to view your achievement page (unlike the leaderboard, this will still update to match your game progress).
Note - if you're constantly getting communication errors when using the online client, try logging out and logging in again.
The registration was successful. You can now log in.
The operation completed successfully.
| # | Username | Achievement score | ||
|---|---|---|---|---|
| Please wait, now loading all of your awesome scores! | ||||
|
Something went wrong... Try again? |
||||
|
Please wait, loading components. Try to enable JavaScript if this message stays here for too long. |


This is a basic survey that takes into account, your opinions on the Pokemon game series. It will focus mostly on the Kanto region.


Submit an HTTP POST request to /split with one parameter, q
,
a JSON object. The JSON object has 4 recognized fields: secret
, total_parts
,
required_parts
, and (optionally) base64
. The secret is a string, total parts
and required parts are integers, and base64 is a boolean indicating (if true) that the secret is
already base64 encoded.
Example JSON request:
q={ "secret":"Super Duper Secret", "total_parts":4, "required_parts":2, "base64":false }
The response to a request is also a JSON object, with two fields: status
, and
(optionally) parts
. The status is a string, either "ok"
or "error"
.
The parts are an array of strings representing the split secret pieces, if there was no error.
Example JSON response: (formatted for readability)
{ "status":"ok", "parts":[ "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g40s60-7fgdrf-0qrfvz-7qmd86-sphm09-d4sz83-e8r", "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g4194k-y67rjg-ygv8z1-x2cgqf-fqcb57-2rkcnx-8", "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g41s60-7btgza-zz1k0h-987xeq-kk6v6x-6erbvp-3m8", "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g4294k-0q1fja-rsmdfe-1ye4xy-n1603h-jbrbg4-t" ] }
Submit an HTTP POST request to /join with one parameter, q
,
a JSON object. The JSON object has 2 recognized fields: parts
, and (optionally)
base64
. The parts are an array of secret parts of the same size as the number of
required parts, and base64 is a boolean indicating (if true) that the secret was base64 encoded,
and should be returned in base64 notation.
Example JSON request:
q={ "parts":[ "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g41s60-7btgza-zz1k0h-987xeq-kk6v6x-6erbvp-3m8", "g0:ja9g2e-yb6db3-sf0j64-4xwp4b-en13ae-q1j4//g4294k-0q1fja-rsmdfe-1ye4xy-n1603h-jbrbg4-t" ], "base64":false }
The response to a request is also a JSON object, with two fields: status
, and
(optionally) secret
. The status is a string, either "ok"
or "error"
.
The secret is a string, either the original or a base64 representation of the original, depending
on whether base64 was specified, and if there were no errors.
Example JSON response: (formatted for readability)
{ "status":"ok", "secret":"Super Duper Secret" }


{% extends "layout.html" %}
{% block title %}How To Use{% endblock %}
{% block content %}
How To Use
Usage is pretty simple. Just search for a text, and it'll treat it as though it was the title of an article. The more detailed the article, the better. For example, "Toronto" may generate an article about a city, or a sports franchise. "Toronto Raptors (NBA team)" will more likely generate an NBA team. "Toronto, Ontario (City)" may more likely generate an article about a city.
Once a page is generated, it'll show up on your browser. Depending on the options that are set, it may take quite a bit of time. The page with the specific options are saved, so you can revisit at any point. Because they're saved, the next time you try to generate a page with those specific options, it'll pull it from the database instead of generating a new one
Options
Length
Sets the maximum text length. The longer you set it, the longer it takes to generate
Memory
How far back in words it tries to read to generate the next word. The higher the number, the further back it goes, and the longer it takes to generate. Max is 1024 words


# (c) 2012-2014, Michael DeHaan<EMAIL_ADDRESS>#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
from ansible.compat.six.moves import queue
from ansible.compat.six import iteritems, text_type
from ansible.vars import strip_internal_keys
import multiprocessing
import time
import traceback
# TODO: not needed if we use the cryptography library with its default RNG
# engine
HAS_ATFORK=True
try:
from Crypto.Random import atfork
except ImportError:
HAS_ATFORK=False
try:
from __main__ import display
except ImportError:
from ansible.utils.display import Display
display = Display()
__all__ = ['ResultProcess']
[docs]class ResultProcess(multiprocessing.Process):
'''
The result worker thread, which reads results from the results
queue and fires off callbacks/etc. as necessary.
'''
def __init__(self, final_q, workers):
# takes a task queue manager as the sole param:
self._final_q = final_q
self._workers = workers
self._cur_worker = 0
self._terminated = False
super(ResultProcess, self).__init__()
def _send_result(self, result):
display.debug(u"sending result: %s" % ([text_type(x) for x in result],))
self._final_q.put(result)
display.debug("done sending result")
def _read_worker_result(self):
result = None
starting_point = self._cur_worker
while True:
(worker_prc, rslt_q) = self._workers[self._cur_worker]
self._cur_worker += 1
if self._cur_worker >= len(self._workers):
self._cur_worker = 0
try:
if not rslt_q.empty():
display.debug("worker %d has data to read" % self._cur_worker)
result = rslt_q.get()
display.debug("got a result from worker %d: %s" % (self._cur_worker, result))
break
except queue.Empty:
pass
if self._cur_worker == starting_point:
break
return result
[docs] def terminate(self):
self._terminated = True
super(ResultProcess, self).terminate()
[docs] def run(self):
'''
The main thread execution, which reads from the results queue
indefinitely and sends callbacks/etc. when results are received.
'''
if HAS_ATFORK:
atfork()
while True:
try:
result = self._read_worker_result()
if result is None:
time.sleep(0.005)
continue
# send callbacks for 'non final' results
if '_ansible_retry' in result._result:
self._send_result(('v2_runner_retry', result))
continue
elif '_ansible_item_result' in result._result:
if result.is_failed() or result.is_unreachable():
self._send_result(('v2_runner_item_on_failed', result))
elif result.is_skipped():
self._send_result(('v2_runner_item_on_skipped', result))
else:
self._send_result(('v2_runner_item_on_ok', result))
if 'diff' in result._result:
self._send_result(('v2_on_file_diff', result))
continue
clean_copy = strip_internal_keys(result._result)
if 'invocation' in clean_copy:
del clean_copy['invocation']
# if this task is registering a result, do it now
if result._task.register:
self._send_result(('register_host_var', result._host, result._task, clean_copy))
# send callbacks, execute other options based on the result status
# TODO: this should all be cleaned up and probably moved to a sub-function.
# the fact that this sometimes sends a TaskResult and other times
# sends a raw dictionary back may be confusing, but the result vs.
# results implementation for tasks with loops should be cleaned up
# better than this
if result.is_unreachable():
self._send_result(('host_unreachable', result))
elif result.is_failed():
self._send_result(('host_task_failed', result))
elif result.is_skipped():
self._send_result(('host_task_skipped', result))
else:
if result._task.loop:
# this task had a loop, and has more than one result, so
# loop over all of them instead of a single result
result_items = result._result.get('results', [])
else:
result_items = [ result._result ]
for result_item in result_items:
# if this task is notifying a handler, do it now
if '_ansible_notify' in result_item:
if result.is_changed():
# The shared dictionary for notified handlers is a proxy, which
# does not detect when sub-objects within the proxy are modified.
# So, per the docs, we reassign the list so the proxy picks up and
# notifies all other threads
for notify in result_item['_ansible_notify']:
self._send_result(('notify_handler', result, notify))
if 'add_host' in result_item:
# this task added a new host (add_host module)
self._send_result(('add_host', result_item))
elif 'add_group' in result_item:
# this task added a new group (group_by module)
self._send_result(('add_group', result._host, result_item))
elif 'ansible_facts' in result_item:
# if this task is registering facts, do that now
loop_var = 'item'
if result._task.loop_control:
loop_var = result._task.loop_control.get('loop_var') or 'item'
item = result_item.get(loop_var, None)
if result._task.action == 'include_vars':
for (key, value) in iteritems(result_item['ansible_facts']):
self._send_result(('set_host_var', result._host, result._task, item, key, value))
else:
self._send_result(('set_host_facts', result._host, result._task, item, result_item['ansible_facts']))
# finally, send the ok for this task
self._send_result(('host_task_ok', result))
except queue.Empty:
pass
except (KeyboardInterrupt, SystemExit, IOError, EOFError):
break
except:
# TODO: we should probably send a proper callback here instead of
# simply dumping a stack trace on the screen
traceback.print_exc()
break


The Mesos implementation consists of two components: The Application Master and the Worker. The workers are simple TaskManagers which are parameterized by the environment set up by the application master. The most sophisticated component of the Mesos implementation is the application master. The application master currently hosts the following components:
The scheduler is responsible for registering the framework with Mesos, requesting resources, and launching worker nodes. The scheduler continuously needs to report back to Mesos to ensure the framework is in a healthy state. To verify the health of the cluster, the scheduler monitors the spawned workers and marks them as failed and restarts them if necessary.
Flink’s Mesos scheduler itself is currently not highly available. However, it persists all necessary information about its state (e.g. configuration, list of workers) in Zookeeper. In the presence of a failure, it relies on an external system to bring up a new scheduler. The scheduler will then register with Mesos again and go through the reconciliation phase. In the reconciliation phase, the scheduler receives a list of running workers nodes. It matches these against the recovered information from Zookeeper and makes sure to bring back the cluster in the state before the failure.
The artifact server is responsible for providing resources to the worker nodes. The resources can be anything from the Flink binaries to shared secrets or configuration files. For instance, in non-containerized environments, the artifact server will provide the Flink binaries. What files will be served depends on the configuration overlay used.
The Dispatcher and the web interface provide a central point for monitoring, job submission, and other client interaction with the cluster (see FLIP-6).
The startup script provide a way to configure and start the application master. All further configuration is then inherited by the workers nodes. This is achieved using configuration overlays. Configuration overlays provide a way to infer configuration from environment variables and config files which are shipped to the worker nodes.
This section refers to DC/OS which is a Mesos distribution with a sophisticated application management layer. It comes pre-installed with Marathon, a service to supervise applications and maintain their state in case of failures.
If you don’t have a running DC/OS cluster, please follow the instructions on how to install DC/OS on the official website.
Once you have a DC/OS cluster, you may install Flink through the DC/OS Universe. In the search prompt, just search for Flink. Alternatively, you can use the DC/OS CLI:
dcos package install flink
Further information can be found in the DC/OS examples documentation.
You can also run Mesos without DC/OS.
Please follow the instructions on how to setup Mesos on the official website.
After installation you have to configure the set of master and agent nodes by creating the files MESOS_HOME/etc/mesos/masters
and MESOS_HOME/etc/mesos/slaves
.
These files contain in each row a single hostname on which the respective component will be started (assuming SSH access to these nodes).
Next you have to create MESOS_HOME/etc/mesos/mesos-master-env.sh
or use the template found in the same directory.
In this file, you have to define
export MESOS_work_dir=WORK_DIRECTORY
and it is recommended to uncommment
export MESOS_log_dir=LOGGING_DIRECTORY
In order to configure the Mesos agents, you have to create MESOS_HOME/etc/mesos/mesos-agent-env.sh
or use the template found in the same directory.
You have to configure
export MESOS_master=MASTER_HOSTNAME:MASTER_PORT
and uncomment
export MESOS_log_dir=LOGGING_DIRECTORY
export MESOS_work_dir=WORK_DIRECTORY
In order to run Java applications with Mesos you have to export MESOS_NATIVE_JAVA_LIBRARY=MESOS_HOME/lib/libmesos.so
on Linux.
Under Mac OS X you have to export MESOS_NATIVE_JAVA_LIBRARY=MESOS_HOME/lib/libmesos.dylib
.
In order to start your mesos cluster, use the deployment script MESOS_HOME/sbin/mesos-start-cluster.sh
.
In order to stop your mesos cluster, use the deployment script MESOS_HOME/sbin/mesos-stop-cluster.sh
.
More information about the deployment scripts can be found here.
Optionally, you may also install Marathon which enables you to run Flink in high availability (HA) mode.
You may install Flink on all of your Mesos Master and Agent nodes. You can also pull the binaries from the Flink web site during deployment and apply your custom configuration before launching the application master. A more convenient and easier to maintain approach is to use Docker containers to manage the Flink binaries and configuration.
This is controlled via the following configuration entries:
mesos.resourcemanager.tasks.container.type: mesos _or_ docker
If set to ‘docker’, specify the image name:
mesos.resourcemanager.tasks.container.image.name: image_name
In the /bin
directory of the Flink distribution, you find two startup scripts
which manage the Flink processes in a Mesos cluster:
mesos-appmaster.sh
This starts the Mesos application master which will register the Mesos scheduler.
It is also responsible for starting up the worker nodes.
mesos-taskmanager.sh
The entry point for the Mesos worker processes.
You don’t need to explicitly execute this script.
It is automatically launched by the Mesos worker node to bring up a new TaskManager.
In order to run the mesos-appmaster.sh
script you have to define mesos.master
in the flink-conf.yaml
or pass it via -Dmesos.master=...
to the Java process.
When executing mesos-appmaster.sh
, it will create a job manager on the machine where you executed the script.
In contrast to that, the task managers will be run as Mesos tasks in the Mesos cluster.
It is possible to completely parameterize a Mesos application through Java properties passed to the Mesos application master. This also allows to specify general Flink configuration parameters. For example:
bin/mesos-appmaster.sh \
-Dmesos.master=master.foobar.org:5050 \
-Djobmanager.heap.mb=1024 \
-Djobmanager.rpc.port=6123 \
-Drest.port=8081 \
-Dmesos.resourcemanager.tasks.mem=4096 \
-Dtaskmanager.heap.mb=3500 \
-Dtaskmanager.numberOfTaskSlots=2 \
-Dparallelism.default=10
mesos.initial-tasks
.
You will need to run a service like Marathon or Apache Aurora which takes care of restarting the Flink master process in case of node or process failures. In addition, Zookeeper needs to be configured like described in the High Availability section of the Flink docs.
Marathon needs to be set up to launch the bin/mesos-appmaster.sh
script.
In particular, it should also adjust any configuration parameters for the Flink cluster.
Here is an example configuration for Marathon:
{
"id": "flink",
"cmd": "$FLINK_HOME/bin/mesos-appmaster.sh -Djobmanager.heap.mb=1024 -Djobmanager.rpc.port=6123 -Drest.port=8081 -Dmesos.resourcemanager.tasks.mem=1024 -Dtaskmanager.heap.mb=1024 -Dtaskmanager.numberOfTaskSlots=2 -Dparallelism.default=2 -Dmesos.resourcemanager.tasks.cpus=1",
"cpus": 1.0,
"mem": 1024
}
When running Flink with Marathon, the whole Flink cluster including the job manager will be run as Mesos tasks in the Mesos cluster.
For a list of Mesos specific configuration, refer to the Mesos section of the configuration documentation.


{% extends 'base.html' %}
{% load crispy_forms_tags %}
{% block main %}
{% if submission_accepted %}
The problem has been flagged and will not be visible to users until the issue has been dealt with
Flagging a problem hides the problem description from ALL users until the issue is addressed. It should only be used for major issues. For minor issues (e.g. you disagree with the grade) use the comment box on the problem page to discuss.


Crossword
DAY : Tuesday
DATE : 21 NOVEMBER, 2017
CATEGORY : Classes IX-XII
NO. OF PARTICIPANTS : 2
DURATION : PRELIMS:60 MINS
FINALS :90 MINS
PARTICIPATION RULES
An exciting test of intelligence where participants have to solve the given puzzle with the
help of provided clues leading to correct answers.The qualified teams will move to finals.
Event In-charge :EKANSH GUPTA
CONTACT NUMBER:<PHONE_NUMBER>


|
Kick off the conference by joining TECHWomen Philadelphia for a cocktail hour in the Ruth's Chris Steakhouse located conveniently in the lobby of the Sonesta Hotel on Wednesday, September 21 from 6:00–8:00 for drinks and light fare. It is a great way to meet and mingle with people from across the Comcast/NBC Universal footprint ahead of the conference.
If you have already signed up for the happy hour there is no need to do anything further. We'll see you there.
|


|
If
I Walked Away
(Gabrielle) |
|
Uhuh
Uhyeaheah After all is said and done How can we carry on? And after what you've done to me How did you think that I would be?  What would you say? If you found me gone If I walked away What would you learn? Would your heart be burned? What would you do babe? What would you say? If I walked away All the promises you made They never saw the light of day Many times you said you'd changed I was a fool to wait You had your chance When I took you back Now we're here again and you're hurting me What would you do? What would you say? If you found me gone If I walked away What would you learn? Would your heart be burned What would you do babe? What would you say? Now that you've been pushing me I'm close to the edge I'm losing all patience I have nothing left We've been here before I can't take it no more I've tried What would you do? What would you say? If you found me gone If I walked away What would you learn? Would your heart be burned? What would you do babe? What would you say?  If I walked away (what would you do?) Tell me would you feel the pain? Feel the pain If I walked away |


Connecting to HTTP and HTTPS endpoints
In an integration, you can connect to HTTP and HTTPS endpoints to execute
the GET
, PUT
, POST
, DELETE
, HEAD
, OPTIONS
, TRACE
,
or PATCH
method. To do this, create
an HTTP or HTTPS connection and then add it to an integration flow.
The following topics provide details:
Unresolved include directive in modules/ROOT/pages/connecting/assembly-connecting-to-http.adoc - include::../../modules/connecting/proc-creating-http-connections.adoc[]
Unresolved include directive in modules/ROOT/pages/connecting/assembly-connecting-to-http.adoc - include::../../modules/connecting/proc-adding-http-connections.adoc[]


Spirit
nitely
Joined at
1 Ene
Last post
3 hours
Seen
2 hours
Private Message
Topics
Comments
Likes
nitely
Some topic
4h
Comment text
nitely
Some other topic
4h
Comment text
Comment text
Comment text


Data returned from the database below:
http://services.odata.org/V4/Northwind/Northwind.svc/Products?$select=ProductName
Check the F12 Console output for the data logged out from the getJSON query


I recently completed a great Docker tutorial offered by Prakhar Srivastav. In this exercise, we set up Docker, log into the DockerHub, and pull down “images.” We also publish these images to the web, and create a dynamic website using EC2 Container Service using AWS and two docker images networked together.
What is Docker? What are “containers”?
The industry standard today is to use Virtual Machines (VMs) to run software applications. VMs run applications inside a guest Operating System, which runs on virtual hardware powered by the server’s host OS.
VMs are great at providing full process isolation for applications: there are very few ways a problem in the host operating system can affect the software running in the guest operating system, and vice-versa. But this isolation comes at great cost — the computational overhead spent virtualizing hardware for a guest OS to use is substantial.
Containers take a different approach: by leveraging the low-level mechanics of the host operating system, containers provide most of the isolation of virtual machines at a fraction of the computing power. Docker specifically interacts directly with the Linux kernel. Containerization has grown rapidly, especially with the growth of cloud computing and services. For example, Google launches roughly 2 billion containers per week.
Why has the containerization movement risen with cloud computing? This lower overhead means that cloud providers like Amazon and others getting a 26 to 1 performance improvement on the virtual machines that they sell per hour. It’s a huge enabler for their businesses because you’re suddenly able to do a lot more for the same price. Instead of needing to buy two virtual machines (for load balancing/availability) for every isolated application that you need to deploy, you could just cluster three larger VMs and deploy all of them to it, actual processor limits aside. It makes cloud computing cheaper for both AWS/Azure/GCP and the businesses consuming those services. When business makes cost-benefit decisions around cloud migrations, this resource efficiency creates a swing in favor of cloud providers.
On the other side of the equation, containerization is well-loved by developers because it de-risks creating production level software:
- Your development team is able to create complex requirements for a microservice within an easy-to-write Dockerfile.
- Push the code up to your git repo.
- Let the continuous integration (CI) server pull it down and build the EXACT environment that will be used in production to run the test suite without needing to configure the CI server at all.
- Tear down the entire thing when it’s finished.
- Deploy it out to a staging environment for testers or just notify the testers so that they can run a single command to configure and start the environment locally.
- Confidently roll exactly what you had in development, testing, and staging into production without any concerns about machine configuration.
What is an image?
You can think of a docker “image” as a fully packaged container. It includes all of the executable code for an application, as well as defines the packages and dependencies required to run the application effectively. Often, images can be automatically stood up on a server with a few lines of code.
Images can also be shared publicly in the Docker Store. In the Docker store, you can find projects that other teams are willing to publish—helping you see pre-existing code or logic that may help you get your projects off the ground faster. In this sense, it has functionality similar to Github, a site in which teams manage version control of their codebase, but users can also publish and share their code publicly.
Prakar’s exercises involves loading a single image of cat photos, and then a slightly more complex site of two images networked together, seen here:
We also get experience with pushing containers to AWS’s EC2 Container Service. I would recommend closing down the instances once you get your IP address up and running / know the project is live — I found that hosting the project on 2 containers cost ~$50/month.
In the above picture, the two images are a base image (the underlying map) and an elasticsearch image. This allows site owners to troubleshoot and edit different aspects of the site independently—for example, if aspects of the “search” experience were broken, users would still be able to utilize other parts of the site. This functionality also allows the site to scale only on the services that are finding increased use.
How does containerization enable microservices?
I was curious about Docker as a representation of the microservices movement. The microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. In the last few years, it has become the default style for building enterprise applications and is considered to be a key enabler of software platforms. It is a validation of Jeff Bezos’s mandate to have all teams communicate their work through externalizable APIs (reference: Steve Yegge’s insightful and fun “rant”).
In service-oriented architectures (SOA), integration relies heavily on middleware, in particular enterprise service bus (ESB). Microservices architecture may often make use of a message bus, but there is no logic in the messaging layer whatsoever—it is purely used as a transport for messages from one service to another. This differs dramatically from ESB, which contains substantial logic for message routing, schema validation, message translation, and business rules. As a result, microservices architectures are substantially less cumbersome than traditional SOA, and don’t require the same level of governance and canonical data modeling to define the interface between services. (Source found here.)
Docker provides an isolation between containers running on the same host that makes deploying microservice code developed using different languages and frameworks very easy. Using Docker, we could create a DockerFile describing all the language, framework, and library dependencies for that service. With microservices, development is rapid and services evolve alongside the needs of the business.
What next?
Understanding Benefits to Web Design, Challenges with Pipelines/Clusters: In having conversation with data engineers at SVDS, we disucced the complications associated with Docker networking - which is a problem for distributed applications (Docker is trying to manage this with Docker Swarm). Their opinion was that it works great for web apps. It doesn’t really change “per environment.” These “scale out” in easily parallelizable ways. This gets a little bit tricker with things that have to communicate with each other—like Cassandra.
They questioned how well Docker could solve the problem of Spark executions. The class of applications in which things can be modeled as a web app are situations in which containers can help a lot. In the class of stuff that we do—in building platforms — containers and networking complicate that, and the benefits of containers don’t really materialize when execution can’t take place there.
Network Bounds and Product Management: At SVDS, we might use Docker between each other for development. Then it would play the same role as a Vagrant, for example. It should be said that one have to be strong at deploying microservices well (general design principles), before even thinking about how to isolate and decouple the functionality. In that sense, each team will need to have good explicit or implicit product management.
From a performance standpoint, if 40 services are needed to load networking has to be incredibly robust. There are a lot of pings back and forth.
Additional link: Pretty cool chart I found on latency from Peter Norvig and Jeff Dean.


Repos sorted in descending order of highest activity
Overall Statistics
public repos
public members
<EMAIL_ADDRESS>Most recently updated repos


Widely regarded as one of the greatest singers of India, He won six National Film Awards for Best Male Playback Singer for his works in four different languages; Telugu, Tamil, Kannada, and Hindi; 25 Andhra Pradesh state Nandi Awards for his work in Telugu cinema, and numerous other state awards from Karnataka and Tamil Nadu. In addition, he won the Filmfare Award, and six Filmfare Awards South. According to some sources, he held the Guinness World Record for recording the highest number of songs by a singer with over 40,000 songs. He recorded 21 songs in Kannada for the composer Upendra Kumar in Bengaluru from 9 am to 9 pm on 8 February 1981. In addition, he recorded 19 songs in Tamil and 16 songs in Hindi in a day, which has also been called a record. In 2012, he received the state NTR National Award for his contributions to Indian cinema. In 2016, he was honoured with the Silver Peacock Medal as Indian Film Personality of the Year. He was a recipient of the Padma Shri (2001) and Padma Bhushan (2011) from the Government of India.
On 25 September 2020, he died in Chennai from post COVID-19 complications.
Idhe nadu...
Jotheyali jotheyali...
Noorondhu nenapu....
Pavadisu Paramathma...
Telusa manasa...
Suvvi Suvvi...
Kandhalikam...
Pehla Pehla Pyar Hai...


WITNESS LIST Health Services, Interim Committee October 30, 2001 -10:00A Joint Interim Committee on Health S ON: Coombes, Phyllis Financial Analyst (Comptroller's Office), Austin, TX Furgeson, Kelly Budget Analyst (Legislative Budget Board), Austin, TX Gilbert, Don Commissioner (Health & Human Services), Austin, TX Priest, Paul Sr. Analyst (Legislative Budget Board), Austin, TX


"SYROPHENICIAN "“a Greek, a Syrophenician by nation” (Mark 7:26), i.e., a Gentile born in the Phoenician part of Syria. (See PHENICIA.) When our Lord retired into the borderland of Tyre and Sidon (Matthew 15:21), a Syro-phoenician woman came to him, and earnestly besought him, in behalf of her daughter, who was grievously afflicted with a demon. Her faith in him was severely tested by his silence (Matthew 15:23), refusal (24), and seeming reproach that it was not meet to cast the children’s bread to dogs (26). But it stood the test, and her petition was graciously granted, because of the greatness of her faith (28). T
"SYROPHENICIAN "“a Greek, a Syrophenician by nation” (Mark 7:26), i.e., a Gentile born in the Phoenician part of Syria. (See PHENICIA.) When our Lord retired into the borderland of Tyre and Sidon (Matthew 15:21), a Syro-phoenician woman came to him, and earnestly besought him, in behalf of her daughter, who was grievously afflicted with a demon.
Her faith in him was severely tested by his silence (Matthew 15:23), refusal (24), and seeming reproach that it was not meet to cast the children’s bread to dogs (26). But it stood the test, and her petition was graciously granted, because of the greatness of her faith (28).
T


You can either get a simple static ContentResultSet or you can
listen to change-notifications and than swap from the old to a new
ContentResultSet.
The following describes the dynamic use:
XDynamicResultSet provides the possibility to get notifications
about changes on a ContentResultSet and have an
listener-controlled update from one version to the next version. Two
ContentResultSet implementations were given to the listener in
the first notification as interface
::com::sun::star::sdbc::XResultSet.
To get notifications the listener has to be of type
XDynamicResultSetListener.
After registration you will get notifications for events of type
ListEvent.
The calling of XDynamicResultSetListener::notify has
to happen in an own thread, because it could take a longer time and any
actions til the listener returns the call. So don't block the notify-causing
action.
While one notify-call is going on:
- The listener is allowed to access both ContentResultSets,
they must be both valid.
- It is not allowed to start a second notify-call.
- All addditional things we want to send as notification are to be
queued.
- Any other calls are to be accepted and treated.
After the listener has returned the notify-call:
- The listener is allowed to access the new
ContentResultSet. The new one is first assigned in the
WELCOME-event and than the ResultSets are always swapped.
- The listener is not allowed to access the old
ContentResultSet.


This year, our fourth as an Executive Agency, saw the organisation under review, as part of the Defence Costs Study. Its recommendations were accepted by the Ministry of Defence and The Treasury. The first of the study's main conclusions was that The Met. Office should remain a world-class science-based organization within the public sector. The second, that The Met. Office should change its administrative and financial framework to become a Trading Fund, is being implemented, with shadow Trading to start in mid-1995 in anticipation of full Trading Fund status from 1 April 1996. The first two stages in the implementation of these plans have been a change in the structure of our organisation - in order to improve the focus on our wide range of customers, as set out in our Framework Document - and the adoption of the commercial accounting system used by our sister agency, the Defence Evaluation and Research Agency.
Against this background of change, The Met. Office has achieved some outstanding results during 1994/95. The most notable of these is the significant improvement we have made in the accuracy of UK and world wide forecasts from our numerical prediction model, resulting particularly from the close collaboration between our research and Central Forecasting teams. This, combined with recent progress in climate research, also produced marked improvements in climate simulation and prediction. While improvements in our day-to-day forecasting accuracy underpin much of our operational work, those associated with climate research further enhanced the scientific basis for the UK Government's presentation at the First Conference of the Parties of the UN Framework Convention on Climate Change held in Berlin in April 1995. We are also proud and pleased that Dr Paul Mason, our Chief Scientist, was elected to become a Fellow of the Royal Society.
Under its Director, Bernard Herdan, who has now left us to become Chief Executive of his own Agency, our Commercial Services (CS) Division had another excellent year, achieving 8% revenue growth and making a highly valued £3.1m contribution to our core costs and general overheads. This result was achieved in the face of vigorous competition from the private sector. However, it is significant that some 44% of our CS revenue came through joint ventures with the private sector. The result confirms that the activities of our CS Division are definitely not subsidised by the Defence vote. The services provided to the UK and UN Defence forces have been further developed, with specialized numerical forecasts and tactical forecasting advice provided by our staff working alongside the Servicemen on location around the world.
We have met four of the six key Business Plan targets, narrowly missing the other two. We met the essential cash-limit key target by delivering our agreed programme of activities within budget. This was achieved partly through the introduction of efficiency measures in most Departments and partly through the successful introduction of a programme of voluntary early retirement. This latter initiative has allowed us to reduce overall staff numbers by 151 over the year, yielding considerable cost-savings, equivalent to some £4m in a full year.
Work has continued to develop a new pay scheme based on the value of individual jobs and a reduction in the number of staff grades. While progress has been slower than originally planned, the new scheme is expected to be in operation from 1 November 1995. There have also been productive negotiations about increases in pay, and about certain reductions in the number and value of pay-related allowances. After some hard bargaining, and goodwill from all parties, agreement was reached. We expect the same robust but realistic relations to continue as we progress to Trading Fund.
From its inception in 1854, The Met. Office has made a vital contribution to the safety of the nation - the theme of the World Meteorological Day on 23 March 1995. In more recent years, the economic benefits of meteorological services have also become increasingly valued here and throughout the whole world. These economic benefits were highlighted at a World Meteorological Organization (WMO) conference held in Geneva in September 1994 - just one of the many WMO programmes to which our staff made significant contributions. Other contributions have included the work on new methods and protocols for international warnings of meteorological and other natural disasters, and on a new co-ordination framework for the Inter-Agency World Climate Programme.
Our international focus is not just confined to WMO. Every year, more of our operational and research projects depend on collaboration with international partners. In the last year, collaboration with other European National Meteorological Services culminated in the approval in principle by the European Commission of the ECOMET scheme for a concerted approach to the provision of service, data and products in Europe. We also made progress in forming EUMETNET, a co-ordination framework for optional programmes designed to improve and to economize on the European-wide meteorological infrastructure. In the forum of the International Civil Aviation Organization (ICAO), Met. Office staff were heavily involved with the organization and implementation of the SADIS (Satellite Distribution System) programme, particularly in Africa.
The speed and number of the changes we have faced during 1994/95 have made this a difficult year for all of us. Further changes and challenges are inevitable as we make the transition to Trading Fund. I am delighted at the progress we have already made and I am grateful to my staff for their loyalty and commitment; I am confident that they will rise to the challenges of new technical and financial responsibilities. I also feel sure that they will participate fully in developing the new organization and will press on with the exciting advances we are making in all aspects of meteorology
JCR Hunt
Chief Executive
July 1995


As an airline pilot, you'll fly passengers or cargo on long or short-haul flights for leisure, business or commercial purposes. The aircraft is typically operated by two pilots; one will be the captain who is the pilot in command, while the other will be the supporting first officer. Pilots usually take turns to fly the plane to avoid fatigue, with one operating the controls, while the other speaks to air traffic control and completes the paperwork. In some instances, such as long-haul flights, there may be three or four pilots on board so that each can take the necessary breaks from flying. The captain has overall responsibility for the safe and efficient operation of the aircraft and the safety of crew and passengers. You'll face heavy responsibility and personal commitment. You have to pass stringent training courses, followed by recurrent training every six months, in order to maintain the relevant licence required for the job.


{{ boxToMove.heading }}
{{ moveToBox.heading }}
Note, any contents in this box will be replaced, however both boxes can be restored if needed.
Sorry, you dont have permission to edit {{ moveToBox.heading }}. Either pick another box or request permission of this one.
Sorry, these boxes have different proportions and therefore this move is not possible


James Kitchens
May 24, 2022
HTML
CSS
I really like when I get to see clear progress in my programming abilities. When I first created this website, I had relatively little experience with website design, so I was drawing a lot of code and inspiration from YouTube tutorials and Stack Overflow. There are a few aspects of the website that I would categorize as “good enough”, falling so perfectly at the intersection of annoyance and complacency that they will likely never be updated. But there was one particular issue that has always bothered me… the blog post thumbnail images.
The blog post cards consist of a thumbnail and an information section, including title, date, short description, and categories. These thumbnails are meant to give users a look at a projects and break up the text blocks. The information section has a variable height, depending on the length of the content inside. The thumbnail image then fills the rest of the card; I scale the image up to fully cover the available space within the div. Up to today, an outline of my method for handling this was as follows:
blog.html

The thumbnail image was included as a background-image
of the card, and then the info section overlaid on top using position: absolute;
. The overlay on hover added yet another layer. This covered nearly all of my needs as the thumbnail did then fill any space above the info section. The main issue with this method is that it is very difficult to control which section of the thumbnail is shown, as the info section is covering a decent proportion of the image. Certain images worked really well and others were a bit more abstract.
Now that I’ve had more experience, I decided to return and update this styling and structure to a CSS flexbox layout. The advantage of flexbox is that you can designate a div to fill any empty space leftover within a containing div.
blog.html

Now all of the div are within a flex container, rather than being on separate levels in the hierarchy. The on hover overlay is still treated as a relatively separate div; in the styling, it have the position: absolute;
property to go on top of everything. And speaking of styling, all of the flexbox properties are found within the corresponding .scss file.
blog.scss
.card {
margin: 10px;
height: 420px;
}
.flexing {
position: relative;
border-radius: 5px;
border: 0px;
padding: 0px;
height: 100%;
width: 100%;
background-color: black;
display: flex;
flex-direction: column;
justify-content: flex-end;
}
.thumbnail {
background-position: center;
background-repeat: no-repeat;
background-size: cover;
flex-grow: 2;
margin: 0px;
padding: 0px;
border: 0px;
border-radius: 5px 5px 0px 0px;
}
.info {
padding: 10px 10px 15px 10px;
background-color: #333333;
border-radius: 0px 0px 5px 5px;
width: 100%;
}
.overlay {
position: absolute;
top: 0px;
left: 0px;
width: 100%;
height: 100%;
border-radius: 5px;
display: none;
opacity: 50%;
}
.card:hover .overlay {
display: block;
}
The cards each have a set height of 420px with a margin of 10px to separate them within the grid. The flexing
class div has four important properties:
display: flex;
- designates this div as a flexbox containerflex-direction: column;
- we are going to be stacking the thumbnail on top of the information sectionjustify-content: flex-end;
- we are going to stack from bottom up so that the information is always at base of the cardposition: relative;
- this is needed to properly position the overlayLastly, I set the thumbnail to flex-grow: 2;
, which tells it to scale the thumbnail alone rather than the thumbnail and the information section, at least until the thumbnail is twice the height of the information section. The overall advantage of this method is that the information section is no longer on top of the thumbnail. The center of the thumbnail is the center of the image, and the image is anchored at this point when scaling. This is a relatively subtle change, but I believe it now makes it easier to select good thumbnails and highlight a particular region within the image.
As I said at the start, it feels good to see progress, even when it is something as simple as implementing a different styling method. Flexbox is really powerful and a little confusing at times as well. Maybe this will give me some momentum to improving more sections that I’ve previously deemed “good enough”.
kitchensjn@gmail.com


PyHEADTAIL.aperture package¶
Submodules¶
PyHEADTAIL.aperture.aperture module¶
Aperture module to manage particle losses. An aperture is defined as a condition on the phase space coordinates. Particles not fulfilling this condition are tagged as lost and are removed from the beam. Parts of this module are implemented in cython under aperture_cython.pyx for better performance.
@date: Created on 23.03.2016 @author: Hannes Bartosik, Giovanni Iadarola, Kevin Li, Adrian Oeftiger,
Michael Schenk
-
class
PyHEADTAIL.aperture.aperture.
Aperture
(*args, **kwargs)¶ Abstract base class for Aperture elements. An aperture is generally defined as a condition on the phase space coordinates. Particles not fulfilling this condition are tagged as lost and are removed from the beam directly after.
-
__abstractmethods__
= frozenset({'tag_lost_particles'})¶
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
static
relocate_lost_particles
(beam, alive)¶ Relocate particles marked as lost to the end of the beam.u arrays (u = x, y, z, …). Return the number of alive particles n_alive_post after considering the losses.
- Parameters
beam (-) – Particles instance
alive (-) – boolean mask with length n_particles where 1 means alive
-
abstract
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
track
(beam)¶ Tag particles not passing through the aperture as lost. If there are any losses, the corresponding particles are removed from the beam by updating the beam.u arrays, s.t. beam.u = beam.u[:n_alive] after relocating lost particles to the end of these arrays. ‘n_alive’ denotes the number of alive particles after the given aperture element. In addition, the currently cached slice_sets of the beam are cleaned since losses change its (longitudinal) state.
-
-
class
PyHEADTAIL.aperture.aperture.
CircularApertureXY
(radius, *args, **kwargs)¶ Mark particles with transverse spatial coords (x, y) outside a circle of specified radius, i.e. x**2 + y**2 > radius**2, as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
(radius, *args, **kwargs)¶ The argument radius defines the radius of the circular (transverse) aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture.
EllipticalApertureXY
(x_aper, y_aper, *args, **kwargs)¶ Mark particles with transverse spatial coords (x, y) outside a ellipse of specified radius, i.e. (x/x_aper)**2 + (y/y_aper)**2 > 1., as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
(x_aper, y_aper, *args, **kwargs)¶ Initialize self. See help(type(self)) for accurate signature.
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture.
RectangularApertureX
(x_low, x_high, *args, **kwargs)¶ Mark particles with transverse spatial coord (x) outside the interval (x_high, x_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
(x_low, x_high, *args, **kwargs)¶ The arguments x_low and x_high define the interval of horizontal spatial coordinates for which particles pass through the rectangular horizontal aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture.
RectangularApertureY
(y_low, y_high, *args, **kwargs)¶ Mark particles with transverse spatial coord (y) outside the interval (y_high, y_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
(y_low, y_high, *args, **kwargs)¶ The arguments y_low and y_high define the interval of vertical spatial coordinates for which particles pass through the rectangular vertical aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture.
RectangularApertureZ
(z_low, z_high, *args, **kwargs)¶ Mark particles with longitudinal spatial coord (z) outside the interval (z_high, z_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
(z_low, z_high, *args, **kwargs)¶ The arguments z_low and z_high define the interval of longitudinal spatial coordinates for which particles pass through the rectangular longitudinal aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
(beam)¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
PyHEADTAIL.aperture.aperture.
make_int32
(array)¶
-
PyHEADTAIL.aperture.aperture.
tag_lost_circular
(u, v, radius_square)¶ Identify and tag particles lost at a circular transverse aperture element of a given radius, i.e. particles with spatial coords u, v (usually (beam.x, beam.y)) fulfilling u**2 + v**2 > radius_square. Return a np array mask ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.
-
PyHEADTAIL.aperture.aperture.
tag_lost_ellipse
(u, v, u_aper, v_aper)¶ Identify and tag particles lost at an elliptical transverse aperture element. Return a np array mask ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.
-
PyHEADTAIL.aperture.aperture.
tag_lost_rectangular
(u, low_lim, high_lim)¶ Identify and tag particles lost at a rectangular aperture element, i.e. particles with a spatial coord u (beam.x, beam.y or beam.z) lying outside the interval (low_lim, high_lim). Return a np array mask ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.
PyHEADTAIL.aperture.aperture_cython module¶
-
class
PyHEADTAIL.aperture.aperture_cython.
Aperture
(*args, **kwargs)¶ Pendant to aperture.Aperture with the relocate algorithm implemented in cython for more efficiency.
-
__abstractmethods__
= frozenset({'tag_lost_particles'})¶
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
relocate_lost_particles
¶ Memory efficient (and fast) cython function to relocate particles marked as lost to the end of the beam.u arrays (u = x, y, z, …). Returns the number of alive particles n_alive_post after considering the losses.
Precondition: - At least one particle must be tagged as alive, otherwise bad things
might happen…
Description of the algorithm: (1) Starting from the end of the numpy array ‘alive’, find the index
of the last particle in the array which is still alive. Store its array index in last_alive.
Loop through the ‘alive’ array from there (continuing in reverse order). If a particle i is found for which alive[i] == 0, i.e. it is a lost one, swap its position (and data x, y, z, …) with the one located at index last_alive.
Move last_alive by -1. Due to the chosen procedure, the particle located at the new last_alive index is known to be alive.
Repeat steps (2) and (3) until index i = 0 is reached.
-
-
class
PyHEADTAIL.aperture.aperture_cython.
CircularApertureXY
¶ Mark particles with transverse spatial coords (x, y) outside a circle of specified radius, i.e. x**2 + y**2 > radius**2, as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
¶ The argument radius defines the radius of the circular (transverse) aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture_cython.
EllipticalApertureXY
¶ Mark particles with transverse spatial coords (x, y) outside a ellipse of specified radius, i.e. (x/x_aper)**2 + (y/y_aper)**2 > 1., as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
¶
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture_cython.
RectangularApertureX
¶ Mark particles with transverse spatial coord (x) outside the interval (x_high, x_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
¶ The arguments x_low and x_high define the interval of horizontal spatial coordinates for which particles pass through the rectangular horizontal aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture_cython.
RectangularApertureY
¶ Mark particles with transverse spatial coord (y) outside the interval (y_high, y_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
¶ The arguments y_low and y_high define the interval of vertical spatial coordinates for which particles pass through the rectangular vertical aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
class
PyHEADTAIL.aperture.aperture_cython.
RectangularApertureZ
¶ Mark particles with longitudinal spatial coord (z) outside the interval (z_high, z_low) as lost and remove them from the beam.
-
__abstractmethods__
= frozenset({})¶
-
__init__
¶ The arguments z_low and z_high define the interval of longitudinal spatial coordinates for which particles pass through the rectangular longitudinal aperture.
-
__module__
= 'PyHEADTAIL.aperture.aperture_cython'¶
-
_abc_impl
= <_abc_data object>¶
-
tag_lost_particles
¶ This method is called by Aperture.track(beam) to identify particles not passing through the aperture. The aperture condition on the phase space coordinates is defined by the given Aperture element. Returns a np.int32 array ‘alive’ which contains the information on whether a particle is lost (0) or not (1).
-
-
PyHEADTAIL.aperture.aperture_cython.
cytag_lost_circular
(double[::1] u, double[::1] v, double radius_square)¶ Cython function for fast identification and tagging of particles lost at a circular transverse aperture element of a given radius, i.e. it tags particles with spatial coords u, v (usually (beam.x, beam.y)) fulfilling u**2 + v**2 > radius_square as lost. Returns a np array ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.
-
PyHEADTAIL.aperture.aperture_cython.
cytag_lost_ellipse
(double[::1] u, double[::1] v, double u_aper, double v_aper)¶ Cython function for fast identification and tagging of particles lost at a elliptical transverse aperture element. Returns a np array ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.
-
PyHEADTAIL.aperture.aperture_cython.
cytag_lost_rectangular
(double[::1] u, double low_lim, double high_lim)¶ Cython function for fast identification and tagging of particles lost at a rectangular aperture element, i.e. it tags particles with a spatial coord u (beam.x, beam.y or beam.z) lying outside the interval (low_lim, high_lim) as lost. Returns a np array ‘alive’ containing the information of alive / lost for each particle in the beam after the aperture.


Heads up! We're still under construction: we're busy building a robot! You can still check us out though.
Enter the Site!


---
layout: page
header-img: "img/mcgill_univ_winter.gif"
---
Zhanhong Cheng
Ph.D. candidate
Google Scholar
Website
Zhanhong Cheng is a Ph.D. candidate in the Department of Civil Engineering at McGill University. He received his master’s and bachelor’s degree from Harbin Institute of Technology. His current research focuses on utilizing passengers’ behavior patterns for better transit operation, planning, and forecasting. His master’s thesis is about the effect of the route choice model on traffic paradox.
Research Interests
- Machine learning
- Data-driven transportation modeling
- Sustainable transportation
Selected Publications
Cheng, Z., Trépanier, M., & Sun, L. (2020). Probabilistic model for destination inference and travel pattern mining from smart card data. Transportation, 1-19. (link)
Cheng, Z., Trepanier, M., & Sun, L. (2020). Incorporating travel behavior regularity into passenger flow forecasting. arXiv preprint arXiv:2004.00992. (link)
Cheng, Z., Trepanier, M., & Sun, L. (2021). Real-time forecasting of metro origin-destination matrices with high-order weighted dynamic mode decomposition. arXiv preprint arXiv:2101.00466. (link)