Plasma donation was happening in a scattered way, so the idea was to bring it at one place in an organised manner.Moreover, basic idea is to provide a simple portal for blood bank and plasma bank. Who can donate plasma? Those aged between 18 and 60 and weighing not less than 50 kg can donate their plasma.A women, who has been pregnant in her life, cannot donate plasma, adding that those people, who take insulin and their sugar level is not stable, also cannot be donors.Those, who have heart, kidney and lung disease, are not eligible to donate their plasma. People having a complaint of hypertension also cannot donate.
If you have fully recovered from COVID-19, you may be able to help patients currently fighting the infection by donating your plasma.
Donate NowBecause anybody fought the infection, his/her plasma now contains COVID-19 antibodies. These antibodies provided one way for your immune system to fight the virus when you were sick, so plasma may be able to be used to help others fight off the disease.
Get Now!You can consider donating blood! One blood donation can save up to three lives. The COVID-19 pandemic has caused unprecedented challenges to the Indian blood supply. Donor centers have experienced a dramatic reduction in donations due to the implementation of social distancing and the cancellation of blood drives.
Donate Now!Either you can submit the above forms and check or
You can view your nearby hospitals on google maps by clicking here.
Everyday, family members and friends of COVID patients are tapping into all their contacts earnestly hoping to find a recovered person who is willing to donate plasma. Convalescent plasma therapy is one of the options explored to save some patients.
Transfusion medicine specialist Dr. Hitesh Kumar, also head of the blood bank at KIMS, explained about who all can
donate plasma, how many times a person can donate plasma, and if there will be any changes to one’s health after the
donation.
Plasma from those who recovered from COVID-19 contains antibodies that neutralise coronavirus. It is expected that the
mortality rate might come down and patients will recover when plasma filled with the neutralising antibodies are infused
into them. The process is still in clinical trial stages at Gandhi Hospital. However, it is increasingly opted at
private hospitals, and thus, the flood of requests from family members desperate to save their loved ones.
Those between the ages of 18 and 55 can donate. People with hypertension and diabetes too are eligible if all other conditions are under control. Patients with HIV, kidney transplant recipients, cancer patients, TB patients, and people who underwent surgery or had a tattoo in the past six months are ineligible.
Btech CSE, VitC
Btech CSE, VitC
Btech CSE, VitC


--- title: "Plumber Package Discussion - Bill McLellan" slug: "apr2020" date: 2020-04-21 ---
Bill led the discussion of Plumber package (video)


The problem of rotation about an arbitrary axis in three dimensions arises in many fields including computer graphics and molecular simulation. In this article we give an algorithm and matrices for doing the movement. Many of the results were initially obtained with Mathematica.
An algorithm (See Figure 1):
(1) Translate space so that the rotation axis passes through the origin.
(2) Rotate space about the z axis so that the rotation axis lies in the xz plane.
(3) Rotate space about the y axis so that the rotation axis lies along the z axis.
(4) Perform the desired rotation by θ about the z axis.
(5) Apply the inverse of step (3).
(6) Apply the inverse of step (2).
(7) Apply the inverse of step (1).
We will write our three-dimensional points in four homogeneous coordinates; i.e., (x,y,z) will be written as (x,y,z, 1). This enables us to do coordinate transformations using 4x4 matrices. Note that these are really only necessary for translations, if we omitted translations from our movements we could do the motions with 3x3 rotation matrices obtained by deleting the last rows and last columns of the 4x4 matrices. In this article vectors are multiplied by matrices on the vector’s left.
The product TP1 ⋅ v is equivalent to the vector sum ⟨-a,-b,-c, 0⟩ + v, i.e., this transformation moves the point P1(a,b,c) to the origin.
Here are the matrices for rotation by α around the x-axis, β around the y-axis, and γ around the z-axis.
The general rotation matrix depends on the order of rotations. The first matrix rotates about x, then y, then z; the second rotates about z, then y, then x.
In this section we introduce matrices to move a rotation vector ⟨u,v,w⟩ to the z-axis. Note that we use the components to form expressions for the cosines and sines to avoid using inverse trigonometric functions. We require that the rotation vector not be parallel to the z-axis, else u = v = 0 and the denominators vanish.
In this section we rotate the point (x,y,z) about the vector ⟨u,v,w⟩ by the angle θ.
This is the product Txz-1T z-1R z(θ)TzTxz.
If we multiply this times ⟨x,y,z⟩ we can obtain a function of of seven variables that yields the result of rotating the point (x,y,z) about the axis ⟨u,v,w⟩ by the angle θ.
f(x,y,z,u,v,w,θ) =
At this point we would like to simplify the expressions by making the assumption that ⟨u,v,w⟩ is a unit vector; i.e., that u2 + v2 + w2 = 1. With this simplification, we obtain the following expression for Txz-1T z-1R z(θ)TzTxz.
If we multiply this times ⟨x,y,z⟩ we can obtain a function of of seven variables that yields the result of rotating the point (x,y,z) about the axis ⟨u,v,w⟩ (where u2 + v2 + w2 = 1) by the angle θ.
f(x,y,z,u,v,w,θ) =
We will define an arbitrary line by a point the line goes through and a direction vector. If the axis of rotation is given by two points P1 = (a,b,c) and P2 = (d,e,f), then a direction vector can be obtained by ⟨u,v,w⟩ = ⟨d-a,e-b,f -c⟩. We can now write a transformation for the rotation of a point about this line.
This is given by the product TP1-1T xz-1T z-1R z(θ)TzTxzTP1. In hopes of fitting the matrix onto the page we make the substitution L = u2 + v2 + w2.
If we multiply this times ⟨x,y,z⟩ we can obtain a function of of ten variables that yields the result of rotating the point (x,y,z) about the line through (a,b,c) with direction vector ⟨u,v,w⟩ by the angle θ.
f(x,y,z,a,b,c,u,v,w,θ) =
Assuming that ⟨u,v,w⟩ is a unit vector so that L = 1, we obtain a more practical result for TP1-1T xz-1T z-1R z(θ)TzTxzTP1.
If we multiply this times ⟨x,y,z⟩ we can obtain a function of of ten variables that yields the result of rotating the point (x,y,z) about the line through (a,b,c) with direction vector ⟨u,v,w⟩ (where u2 + v2 + w2 = 1) by the angle θ.
f(x,y,z,a,b,c,u,v,w,θ) =
A graphic visualization of rotating a point about a line can be found at http://twist-and-shout.appspot.com/.
Tested Java code for the matrices and formulas, released under the Apache license, is at https://sites.google.com/site/glennmurray/Home/rotation-matrices-and-formulas.


Break out! helps you to 'break out' of what you are doing at a given time. You can use this for example to help you learn new habits, return to the present moment, or train your awareness. Essentially, Break out! helps you to remind yourself of something in an intuitive way.
Examples of messages that you could use:
Idea: Ronald Bos.
Built by:
Source code on GitHub: https://github.com/martentamerius/TrainJezelf/tree/master.
This app uses the following components:


Before Change
experiment["platform_accession_code"] = UNKNOWN
experiment["platform_accession_name"] = UNKNOWN
else:
if parsed_json["arraydesign"][0]["accession"] not in settings.SUPPORTED_PLATFORMS:
logger.warn("Experiment platform %s is not supported!",
parsed_json["arraydesign"][0]["accession"],
experiment_accession_code=experiment_accession_code,
After Change
experiment["platform_accession_name"] = UNKNOWN
else:
external_accession = parsed_json["arraydesign"][0]["accession"]
for platform in get_supported_microarray_platforms():
if platform["external_accession"] == external_accession:
experiment["platform_accession_code"] = platform["platform_accession"]
platform_mapping = get_readable_platform_names()
experiment["platform_accession_name"] = platform_mapping[
platform["platform_accession"]]
if "platform_accession_code" not in experiment:
// We don"t know what platform this accession corresponds to.
experiment["platform_accession_code"] = external_accession
experiment["platform_accession_name"] = UNKNOWN


News Article Social Media Post
Fake News Detection
It predicts and analyses the fake news.
Submit
Clickbait Detection
It checks clickbaitness of social media post.


International Financial Reporting Standard 5 Non-current Assets Held for Sale and Discontinued Operations (IFRS 5) sets out requirements for the classification, measurement and presentation of non-current assets held for sale and replaces IAS 35,Discontinuing Operations.
IFRS 5 requires that it shall be applied prospectively to non-current assets (or disposal groups) that meet the criteria to be classified as held for sale and operations that meet the criteria to be classified as discontinued after the effective date of the IFRS.
Click the highlighted area to find out more.


Choices:
Name
Address
Stars
Floor
Wing description
Wing type
Name
Address
Stars
Stars
Stars
Stars
Choose:
Select room!


Home
My Profile
Logout
Welcome to CommunityFund, lets set up your profile.
Please fill out your personal info.
What are your interests?
Email address
More
Create Profile
Explore Communities


Watch
(object in module decipher.history
)
An object instance that provides several methods for executing handlers after certain changes have been made.
Each function return the Watch
instance, so you can chain the calls.
See the docs for History.deepWatch() for an example of using these functions.
Adds a change handler function with name name
to be executed
whenever a value matching this watch's expression changes (is archived).
name – {string} –
Unique name of handler
fn – {Function} –
Function to execute upon change
resolve – {object} –
Mapping of function parameters to values
{Watch}
– This Watch instance
Adds a rollback handler function with name name
to be executed
whenever the batch tied to this watch is rolled back.
name – {string} –
Unique name of handler
fn – {Function} –
Function to execute upon change
resolve – {object} –
Mapping of function parameters to values
{Watch}
– This Watch instance
Adds a redo handler function with name name
to be executed
whenever a value matching this watch's expression is redone.
name – {string} –
Unique name of handler
fn – {Function} –
Function to execute upon change
resolve – {object} –
Mapping of function parameters to values
{Watch}
– This Watch instance
Adds a revert handler function with name name
to be executed
whenever a value matching this watch's expression is reverted.
name – {string} –
Unique name of handler
fn – {Function} –
Function to execute upon change
resolve – {object} –
Mapping of function parameters to values
{Watch}
– This Watch instance
Adds an undo handler function with name name
to be executed
whenever a value matching this watch's expression is undone.
name – {string} –
Unique name of handler
fn – {Function} –
Function to execute upon change
resolve – {object} –
Mapping of function parameters to values
{Watch}
– This Watch instance
Removes a change handler with name name
.
name – {string} –
Name of handler to remove
{Watch}
– This Watch instance
Removes a redo handler with name name
.
name – {string} –
Name of handler to remove
{Watch}
– This Watch instance
Removes a revert handler with name name
.
name – {string} –
Name of handler to remove
{Watch}
– This Watch instance
Removes a rollback handler with name name
.
name – {string} –
Name of handler to remove
{Watch}
– This Watch instance
Removes a undo handler with name name
.
name – {string} –
Name of handler to remove
{Watch}
– This Watch instance


The 300 Seconds Kevin Flynn Javascript Quizz
Rules
Each Correct Answer: +10 Pts
Each Incorrect Answer: -10 Seconds of Playing Time
300 Seconds (5 minutes) to answer all 20 questions.
Time Left:
Score:


Analyst and Designer
Jonathan Dickins
I'm a data analyst and visualisation developer, particularly interested in research and education markets. I hold a PhD from the University of Southampton in cogitive
psychology, and have 8 years of experience deriving and communicating insights from data.


Transparency data
Funding allocated to local authorities for their schools budget for the 2015 to 2016 financial year.
PDF , 232KB , 12 pages
PDF , 266KB , 20 pages
PDF , 214KB , 11 pages
MS Excel Spreadsheet , 809KB
MS Excel Spreadsheet , 183KB
Information on dedicated schools grant ( DSG ) allocations for the 2015 to 2016 financial year, including:
More information is available in ‘Fairer schools funding: arrangements for 2015 to 2016’ .
You can also read the written ministerial statement on education funding issued on 17 December 2014.
Published: 17 December 2014
Updated: 10 August 2016


This page tests your connectivity to Licode server
Local video (got from your local camera)
Subscribed video (how other participant will see you once your local video is published)


{% extends 'base.html' %} {% block content %} {% if message %}
Please confirm to delete your account "{{ user.email }}" and all associated data.


| Trees | Indices | Toggle frames |
|---|
AbstractImage --+ | Texture --+ | TileableTexture
A texture that can be tiled efficiently.
Use create_for_image classmethod to construct.
| __init__(self, width, height, target, id) | |
| AbstractImage |
get_region(self,
x,
y,
width,
height)
Retrieve a rectangular region of this image.
|
|
blit_tiled(self,
x,
y,
z,
width,
height)
Blit this texture tiled over the given area.
|
|
| create_for_image(cls, image) | |
| __del__(self) (Inherited from pyglet.image.Texture) | |
| __repr__(self) (Inherited from pyglet.image.AbstractImage) | |
|
blit(self,
x,
y,
z=0,
width=None,
height=None)
Draw this image to the active framebuffers.
(Inherited from pyglet.image.Texture)
|
|
|
blit_into(self,
source,
x,
y,
z)
Draw
(Inherited from pyglet.image.Texture)
source on this image. |
|
|
blit_to_texture(self,
target,
level,
x,
y,
z=0)
Draw this image on the currently bound texture at
(Inherited from pyglet.image.AbstractImage)
target . |
|
| Texture |
create(cls,
width,
height,
internalformat=6408,
rectangle=False)
Create an empty Texture.
(Inherited from pyglet.image.Texture)
|
| Texture |
create_for_size(cls,
target,
min_width,
min_height,
internalformat=None)
Create a Texture with dimensions at least min_width, min_height.
(Inherited from pyglet.image.Texture)
|
|
delete(self)
Delete the texture from video memory.
(Inherited from pyglet.image.Texture)
|
|
| ImageData |
get_image_data(self,
z=0)
Get the image data of this texture.
(Inherited from pyglet.image.Texture)
|
| Texture |
get_mipmapped_texture(self)
Retrieve a Texture instance with all mipmap levels filled in.
(Inherited from pyglet.image.AbstractImage)
|
| Texture |
get_texture(self,
rectangle=False)
A Texture view of this image.
(Inherited from pyglet.image.Texture)
|
| TextureRegion |
get_transform(self,
flip_x=False,
flip_y=False,
rotate=0)
Create a copy of this image applying a simple transformation.
(Inherited from pyglet.image.Texture)
|
|
save(self,
filename=None,
file=None,
encoder=None)
Save this image to a file.
(Inherited from pyglet.image.AbstractImage)
|
| ImageData |
image_data
An ImageData view of this texture.
(Inherited from pyglet.image.Texture)
|
| Texture |
mipmapped_texture
A Texture view of this image.
(Inherited from pyglet.image.AbstractImage)
|
| Texture |
texture
Get a Texture view of this image.
(Inherited from pyglet.image.AbstractImage)
|
| int |
anchor_x = 0
X coordinate of anchor, relative to left edge of image data
(Inherited from pyglet.image.AbstractImage)
|
| int |
anchor_y = 0
Y coordinate of anchor, relative to bottom edge of image data
(Inherited from pyglet.image.AbstractImage)
|
| int |
height
Height of image
(Inherited from pyglet.image.AbstractImage)
|
| int |
level = 0
The mipmap level of this texture.
(Inherited from pyglet.image.Texture)
|
| class (subclass of TextureRegion) |
region_class
Class to use when constructing regions of this texture.
(Inherited from pyglet.image.Texture)
|
| int |
target
The GL texture target (e.g., GL_TEXTURE_2D).
(Inherited from pyglet.image.Texture)
|
| tuple |
tex_coords =
12-tuple of float, named (u1, v1, r1, u2, v2, r2, ...).
(Inherited from pyglet.image.Texture)
|
| int |
width
Width of image
(Inherited from pyglet.image.AbstractImage)
|
images = 1
(Inherited from pyglet.image.Texture)
|
|
tex_coords_order =
(Inherited from pyglet.image.Texture)
|
|
x = 0
(Inherited from pyglet.image.Texture)
|
|
y = 0
(Inherited from pyglet.image.Texture)
|
|
z = 0
(Inherited from pyglet.image.Texture)
|
Blit this texture tiled over the given area.
The image will be tiled with the bottom-left corner of the destination rectangle aligned with the anchor point of this texture.
| Trees | Indices | Toggle frames |
|---|
| Generated by Epydoc 3.0beta1 on Sun Mar 22 20:15:40 2009 | http://epydoc.sourceforge.net |


The following graphic shows the status of the Eddy sistem.
It should shows three panels, one for each tower.
If one is not appearing it is off!
Legend: 1 or 2 means that system is on operation


Please feel free to reach out with any questions you may have!
Name is required.
Email is required.
Please include a message for the email.


General election: Moving handwritten Tory Story signs pop up across UK
They have been putting up notices and posting pictures with the hashtag #Torystory
by Nicola Bartlett, https://www.mirror.co.uk/authors/nicola-bartlett/People have been sharing their experiences of living in Tory Britain on social media.
From waiting times in the NHS to struggles with insecure work, they paint a stark picture of the damage cuts have done to the UK over the last nine years.
The grassroots campaign really took off this afternoon with people writing out their stories and pinning them up on posts and at bus stops.
They then took a picture of the notice and tweeted it with the hashtag #Torystory.
These are some of the harrowing stories:
Waiting three years for an autism diagnosis
"A while ago, I realised that I matched a lot of the characteristics for austism I went to the GP and explained this, and talked about how this means I find work much more difficult, contributes to my mental health problems and causes issues in my relationshops.
"I was put on a waiting list to be seen by a specialist.
"The waiting list was three years long.
"I, and many other autistic adults, cant get the support we need due to Tory cuts."
Waiting eight months for mental health treatment
"In March I was suicidal.
"I was referred for CBT.
"I'm still waiting.
"Mental health services have been neglected for too long."
"I spent the night on a trolley in a store cupboard"
The Tories are destroying the NHS.
"I was admitted to hospital with a suspected heart attack.
"All the beds in the hospital were full I spent the night on a trolley in a store cupboard, with no windows, sink or even an emergency call button.
"The staff are so overworked, trying to care for 37 patients with 3 qualified nurses.
"The NHS can't survive for another 5 years of this Tory government.
"Vote Labour on December 12th to save the NHS."
Broken respirator
"In 2017 I gave birth to my daughter.
"It was quick - I was in the birthing room for less than two hours.
"The midwife had to spend most of this time wrestling with the clunky slow computer to fill in forms when it came to checking equipments in the room she found that the baby respirator wasn't working.
"We were lucky.
"My daughter was born healthy but what if we weren't so lucky?
"What if we had needed that respirator?
"Tory cuts are putting the lives of newborns at risk.
"To end the cuts and save the NHS vote Labour on 12th December."
"I can't afford to feed my kids"
"I lost my job last year, now work zero hours contract.
"I often don't have enough hours to pay for my kids to eat, so go to food banks for the first time in my life.
"We have to vote the Tories out."


{% extends "layout.html" %} {% block page_title %} Your partner - Budgeting Loans - GOV.UK {% endblock %} {% block content %} {% include "includes/beta-banner.html" %} {% if edit %} {% else %} {# Back link #} {% import "includes/back-link.html" as back %} {{ back.url('4-industrial-action') }} {# Back link #} {% endif %} Do you have a partner? Do you have a partner? A partner is someone over the age of 16 who you’re married to or live with as if you’re married to them. Yes No {% include "includes/continue-save.html" %} {# / column-two-thirds #} {# / grid-row #} {% endblock %}
A partner is someone over the age of 16 who you’re married to or live with as if you’re married to them.


Toggle navigation
My Record
My Billing
My Notes
My Files
DEMO
My Profile
My Account
Log out
Toggle navigation
Sign Up
Log In


Haus Himmelreich
The house
I started photography for our own house with holiday apartments. I did the pictures of the house and the rooms. I quickly changed my gear to a full frame camera Nikon D800 and some acceptable lenses for Zoom, Wideangle and Macro, but also some fixed lengths like a 50mm lense.
The hiking and ski tours
To give our guests an idea of how it is to live in the Kleinwalsertal, I take my camera with me on most of our hiking tours with the dogs and the kids.
The people
I do only a little people photography. Mostly of course for the family.
Das Naturhotel Chesa Valisa
The house
I shot most of the pictures of the Naturhotel, while working at the reception. I updated the pictures of all old and new rooms and the house itself from outside during the different seasons.
The SPA
It's really fun to make pictures of an outside SPA area during winter.
The restaurant & events
My pictures were mostly of the restaurant prepared for dinner and large events like christmas, new year or carnival.
My Hobby
Night
I managed to take some decent shots of the milky way. It's great to be outside at night trying to take a photo of stars you hardly can see by yourself.
Macro
Next comes the macro photography. You almost can't see anything. But the camera gets every little hair of an insect.
Landscape
Last but not least! I love the landscape of the Kleinwalsertal during every season. It's fantastic during winter covered in fresh snow. And a great contrast in summer with its green woods and mountains.


Purpose of this article is to create an index for the classes and modules defined in the projects. And guide the future development based on the work.
Note that the css file used for this README article is one of the css files hosted on Github.
defined in "BCNetwork.h"
template<typename compType, typename rateType, typename powerType>
class BCNetwork
This module is the basic module to store the information necessary to describe a biochemical network. It is supposed to be able to handle all types of biochemical networks(from elemental to huge, both discrete and continuous.)
| typename | meaning |
|---|---|
compType |
data type of the amount of reactants |
rateType |
data type of the reactant constants |
powerType |
data type of both rate matrix and update matrix |
type variable_name |
meaning |
|---|---|
double t |
current time of the network |
int nComp |
number of reactants |
compType * comp |
pointer to datablock that store amount of each reactants |
compType * compBackup |
same as comp , a back up datablock for resetting purpose |
int nRate |
number of rate constants |
rateType * rate |
pointer to datablock that store each rate constants |
powerType * rateMatrix |
pointer to datablock for rate matrix. Format: i*nComp+j |
powerType * updateMatrix |
pointer to datablock for update matrix. Format, as above. |
int loadParameter(vector<compType> &, vector<rateType> &, powerType *, powerType *);
Load parameter from a certain model. Four types of parameters required to fully describe a model are required. the four inputs are respectively : amount of reactants as a form of vector; amount of rate constants as a form of vector; rate matrix as a datablock of same format as described in variable members; update matrix as a datablock of same requirement.
loadParameter will import all the information obtained from the input into the inbuilt dataset. So the destruction of input source after the import will not disturb the funtion of this modules or any modules that inherit from it.
Importing a second network will overwrite the previous one stored in. The previous network will be automatically completely erased before a second network is written in, so backup is suggested before this action.
int fileOpen(string & condition);
int fileClose();
Open and close a data saving file. fileOpen(string &)
will open a data file with name "./result/sim$(condition)". New file will be created if it is not exist. And older data willed be wiped in the file with a same name. Note that new folder won't be created if not exist. So a folder "result" created under the working directory before running the code is suggested.
Note that the folder name "./result/" is defined in "basicDef.h" as
#define RESULTFOLDER "./result/"
virtual void saveData();
Essentially this function will toss a copy of the current time and amount of each reactants into the data file opened by int fileOpen(string &)
. Data will be saved in a file named "./result/simEmergency" if no file is opened. But open a file before saving the data is still suggested.
Note that this member function covers only the basic saving feature and changable in classes inherit this class template.
virtual void reset();
Restore the datablock that * comp
pointing to with the datablock pointed by * compBackup
. And again, this member function is preliminary and changable in classed derived from this class template.
BCNetwork();
BCNetwork(vector<compType> & initComp, vector<rateType> & inputRate,
powerType * inputRateMatrix, powerType * inputUpdateMatrix);
~BCNetwork();
BCNetwork()
only setting private members to correct initial value for the class to function correctly. BCNetwork(vector<compType> &, vector<rateType> &, powerType *, powerType *)
will call int loadParameter(...)
to load a model when initiating the class. ~BCNetwork()
will free all memory that allocated from this class template before its destruction.
defined in "modelLoader.h"
template <typename compType, typename rateType, typename powerType >
class modelLoader
This class template is merely used to load a model from file. The use of this class is temporary before it's function incorporated into BCNetwork
class template.
void loadParameter(string & mName);
This is the only functional member. It's used to load model parameters stored in folder "./mName". The format of model parameters will be specified in a model creation/modification project. To completely load a model, four files will be read. The name of them are specified as macros stored in "basicDef.h":
#define RATEFILE "rate" // reaction rate constants, first line is the number of reactions
#define INITCONDFILE "initCond" //initial condition for each reactants, first line is
//the number of reactants
#define RATEMATRIXFILE "rMatrix" //rate matrix, same format as in datablock
#define UPDATEMATRIXFILE "updMatrix" //update matrix, same format as in datablock
modelLoader(string & mName);
~modelLoader();
modelLoader(string &)
calls loadParameter(string &)
. This is the only valid way of initiating modelLoader class. Other ways of initiating this class may involve unexpected behavior.
defined in "ODECommon.h"
class ODENetwork : public BCNetwork<double, double, int>
This is the basic class for biochemical networks described by ODEs. In addition to the features already defined in BCNetwork
class template, the ODEs required for simulation and time variable will be defined in this class. But neither simulation nor analysis feature is defined in this class.
These chemical networks are defined in continuous space and are deterministic. Thus both reactant amount datatype and reaction rate datatype are double.
Note, the two matrices in most cases are integer, thus the powerType is defined so. For specific cases that require non-integer powerType, change the type accordingly.
type variable_name |
meaning |
|---|---|
double h0 |
initial size of time step |
void ODETimeDeri(double * timeDeri, double * component);
This is the ODEs generated from the biochemical network. The usage of the ODEs is to feed 2 pointers to the function. * component
point to the datablock of current reactant amounts; *timeDeri
point to the datablock that stores the time derivations of each reactants' amount.
Note that the datablock pointed by timeDeri will be changed after this function is called. Backup is suggested if there is anything you don't want to be erased there.
ODENetwork(vector<double> & initComp, vector<double> & inputRate,
int * inputRateMatrix, int * inputUpdateMatrix, double
initTimeStep) :
BCNetwork<double,double,int>
(initComp, inputRate, inputRateMatrix, inputUpdateMatrix);
Well, basically it's self explined. It does two things. It calls the constructor that loads a biochemical network, and give h0
an initial value given by user.
Reaction network will be stored as a folder named by the network name. In the folder, there will be 2 files, reaction
and reactant
. In reactant
, initial values of all relative reactants is to be stored respectively. Number of values will be treated as the number of reactants. In reaction
, all reactions in the network is to be stored respectively. Format of reactions is as followed:
code
rate_0
rate_1
rate_2
rate_3
dep_0
dep_1
dep_2
upd_num
upd_0
upd_1
upd_2
where each xxx
represent a value/group of values, either integer or decimal. Meaning of them are as following:
| name | meaning |
|---|---|
code |
int , used to identify reaction type |
rate_0~3 |
float , store reaction constants. Depending on reaction type, not all 4 of them are necessarily meaningful. |
dep_0~2 |
int , store reaction rate dependency on reactants. Each int represents the serial of the respective reactant. Depending on reaction type, not all 3 of them are necessarily meaningful. |
upd_num |
int ranged from 0~3 , number of reactants to be updated. |
upd_0~2 |
int <tab> double , store the serial number and number of molecules change by each instance of reaction. Dependingon upd_num , not all 3 of them are necessarily meaningful. |
Though not necessary, it is recommended that one line is to store the information of one reaction.
In coarse grained model, we describe the reactions into 5 types. Those reaction types should be able to describe almost all reactions seen in reaction networks, the following table is the storage format of each reaction type.
| type | code |
rate_0~3 |
dep_0~2 |
upd_num |
upd_0~2 |
|---|---|---|---|---|---|
*->.. |
0 | k rand rand rand |
rand rand rand |
r. spec. |
r. spec. |
A->.. |
1 | k rand rand rand |
A rand rand |
r. spec. |
r. spec. |
A+B->.. |
2 | k rand rand rand |
A B rand |
r. spec. |
r. spec. |
| Act. Hill equa. Or. 1 | 3 | k K n rand |
P factor rand |
r. spec. |
r. spec. |
| MM kinetics | 4 | k K rand rand |
S E rand |
r. spec. |
r. spec. |
| Inh. Hill equa. Or. 1 | 5 | k K n rand |
P factor rand |
r. spec. |
r. spec. |
| Inh. Hill equa. MM K. | 6 | km Km Kh n |
P factor S |
r. spec. |
r. spec. |
| MM kinetics | 7 | k K rand rand |
S rand rand |
r. spec. |
r. spec. |
A+B+C->.. |
8 | k rand rand rand |
A B C |
r. spec. |
r. spec. |
Note:
1. Update reactants are case by case specific, thus not described here.
2. The four cases defined here are the four standard cases defined in
`class coarseGrainedModel<compType, updRateType>`.
3. Hill equation usually follows some other reaction, here we define only the case
that combined protein being able to trigger some type `1` reaction with rate `k`.
The equilibrium constant of factor combining is `K`.
4. New reaction types can be added, as described in
`class coarseGrainedModel<compType, updRateType>`.
defined in "coarseGrainedCommon.h"
struct reaction
This structure is to store the information used to describe one reaction in coarse grained models.
Note: It is not suggested for reactions to be modified after loaded from file, but on necessary occations, the following will serve a guide on the format information stored in the structure.
type variable_name |
meaning |
|---|---|
int code |
code to identify the reaction type |
double rate[MAXRATECOEF] |
rate coefficients of the reaction |
int dependency[MAXDEPENDENCY] |
reactant dependency of the reaction rate |
int updateNumber |
number of reactant to be updated |
int updateSet[MAXUPDSET] |
the set of reactants to be updated by the reaction |
double updateOrder[MAXUPDSET] |
updateOrder[i] gives the amount of reactant change for reactant updateSet[i] . |
Note: updateOrder[i], updateOrder[i]
together is the ith instance of upd_0~2
mentioned in section Reaction network format.
reaction & operator=(const reaction & dummy);
The function will copy all values stored in dummy to the current reaction
instance and return the pointer of current instance.
bool loadReaction(ifstream & reactionFile);
The function member will read 12 values from reactionFile
. And store the information in the current reaction
instance in a format described in section Reaction network format. Returned value is the EOF flag of file pointer reactionFile
.
void erase()
reset all values in this reaction
instance to 0
.
reaction()
reaction(const reaction & dummy)
The default constructor creates a all zero valued instance of reaction
. The copy constructor copies all values stored in dummy to the current reaction
instance.
defined in "coarseGrainedOperation.h"
template<typename compType>
struct trajectory
This structure stores the trajectory of a certain network within a period of time. It is defined before or during a simulation. A saving member is also defined so that the data can be written into file whenever needed.
type variable_name |
meaning |
|---|---|
int nComp |
number of reactants in the network. |
double * time |
time points on the trajectory; |
compType comp |
storage for number of each reactant at each time point. Format: comp[t*nComp+i] . |
long trajectoryPointer |
writing pointer, indicate the location to write when using void assign(int, long) to write new data or how many data values to save when using void save(string, bool) to write data to disk. |
void append(double time_alias, compType * comp_alias);
Though it's OK for user to write trajectory data by themselves, this function will append data to the end of the last written data block, and push trajectoryPointer
one unit further.
void save( string & outputFileName, bool append=1);
Saving the data currently written to the memory block to the point where trajectoryPointer
indicates to a file, named with outputFileName
. If append=1
as default, the data will be appended at the end of the file. While if indicating append=0
, the original file will be replaced without warning.
void erase();
This funtion will erase the current assigned memory if exists. trajectoryPointer
will also point to 0.
void reallocate(int nComp_alias, unsigned long trajectorySize);
Erase(with erase()
) currently assigned memory if exists, and reallocate memory for *comp
with sizenComp_alias*trajectorySize
, and *time
with size trajectorySize
. All values of newly assigned memory will be zero.
trajectory();
trajectory(int nComp_alias, unsigned long trajectorySize_alias);
trajectory(trajectory<compType> & dummy);
Default constructor create an empty trajectory
structure. To use, user must first use void reallocate(int nComp_alias, unsigned long trajectorySize)
defined as a public function member to allocate memory for the trajectory.
trajectory(int nComp_alias, unsigned long trajectorySize_alias);
automatically calls void rellocate(int, unsigned long)
, thus the datablock will be ready for all operations when this constructor is used.
Copy constructor will create an exact duplicate of dummy trajectory
.
defined in "coarseGrainedCommon.h"
template<typename compType, typename updRateType>
class coarseGrainedModel;
This class template defines a basic structure to store information of a coarse grained biochemical network. It also provides basic reaction rate determination method and reactant update method. compType
is the type for reactant amounts, can be both int
or double
. updRateType
is the type of * rate
used when determining the amount of reactant to be updated. It's suggested to be double
. But other variable type is still OK.
type variable_name |
meaning |
|---|---|
int nComp |
number of different reactants in the network |
compType * comp |
datablock to store amount of each reactant of current time |
int nReact |
number of reactions in the network. |
reaction * react |
an array to store all reactions in the network. |
double time |
current time |
double lastSavedTime |
last saved time point |
double stoppingTime |
time when simulation ends |
double saveTimeInterval |
time interval between two saving points |
virtual int modelLoading(string & modelName);
Load model from a folder named modelName
.
int rateDetermine(double * rate, compType * comp_alias);
int rateDetermine(double * rate);
int rateDetermine(double *, compType *)
use the reactant information stored in * comp_alias
to calculate the reaction rate. Calculated reaction rate is released in array pointed by * rate
. For int rateDetermine(double *)
, reactant information used is the one pointed by * comp
.
int reactantUpdate(compType * comp_alias, const updRateType * rate);
int reactantUpdate(const updRateType * rate);
int reactantUpdate(compType *, const updRateType *)
will use *rate
times the update information stored in each reaction to update reactant amounts stored in * comp_alias
. In int reactantUpdate(const updRateType *)
, the target reactant amounts storage would be * comp
.
void reset()
Reset data pointed by *comp
with the condition loaded from model file. And setting time
and lastSavedTime
to 0
.
void assign(const coarseGrainedModel & dummy)
Duplicate EVERYTHING from the dummy into the current coarseGrainedModel
.
coarseGrainedModel();
coarseGrainedModel(string & modelName);
coarseGrainedModel(const coarseGrainedModel<compType, updRateType> & dummy);
Default constructor won't create a workable instance. User need to load a model from file with int modelLoading(string &)
before any other operation.
coarseGrainedModel(string &)
loads a model from file automatically and creates a working instance.
Copy constructor duplicate the dummy coarseGrainedModel
into a new instance.
defined in "coarseGrainedOperation.h"
class coarseGrainedStochastic: public coarseGrainedModel<int,double> ,
public gillespie<coarseGrainedStochastic>
This class is based on coarseGrainedModel, using gillespie module for simulation.
void reset();
void assign(const coarseGrainedStochastic & dummy);
These two function members are inherited from coarseGrainedModel
.
void simulate(string fileName);
Simulate with gillespie module. The resulting data will be put into a file named by fileName
. This is a temporary design, and will be replaced by other modules when multi-thread simulation steps in.
coarseGrainedStochastic(string & modelName, double stoppingTime_alias,
double saveTimeInterval_alias):
coarseGrainedModel<int,double>(modelName), gillespie<coarseGrainedStochastic>
(nReact,
&coarseGrainedModel::rateDetermine,
&coarseGrainedModel::reactantUpdate);
coarseGrainedStochastic(coarseGrainedStochastic & dummy):
coarseGrainedModel<int,double>(dummy),
gillespie<coarseGrainedStochastic>(nReact,
&coarseGrainedModel::rateDetermine,
&coarseGrainedModel::reactantUpdate)
Aside of the behavior inherited from the base classes, the constructors shown above will take stoppingTime
and saveTimeInterval
information from either user input or dummy
.
The following classes are defined as algorithms used for biochemical network related simulation.
defined in "gillespieStandAlone.h" Note: This module used to be called gillespie
. However, the stand alone design is outdated and is already replaced by the new gillespie
class. Old version is thus changed into gillespieStandAlone
for reference purpose.
class gillespieStandAlone: public BCNetwork<int, double, int>
This class defines both the algorithm and the simulation methods. Gillespie algorithm is an exact simulator for biochemical reactions. Continuum approximation won't work here. Thus the datatype of reactant amounts are integer. So far I didn't see the necessity of seperating them. But when there is a need, they might be seperated in the future.
type variable_name |
meaning |
|---|---|
double stoppingTime |
the stopping signal for the simulation |
long long int savePointInterval |
the interval of saving points by count of steps |
long long int nOfNewStep |
No. of steps since the last saving point |
double saveTimeInterval |
the interval of saving points measured by time interval |
double lastSavedTime |
the time point in which last saving action has taken places. |
bool saveMethod |
0=save every savePointInterval steps; 1=save every saveTimeInterval of time; |
bool noSave |
If noSave signal is 1, no data saving is allowed |
void simulate();
This function will iterate the network with Gillespie algorithm till BCNetwork::t
(defined in BCNetwork class template) surpasses stoppingTime
. During the simulation, once the saving condition is satisfied, the current time and the current datablock that BCNetwork:: *comp
points to will be saved into file specified by BCNetwork::fileOpen(string &)
.
inline void reset();
This reset function reserves the function of BCNetwork::reset()
. It also restore BCNetwork::t
, lastSavedTime
and nOfNewStep
to 0.
gillespieStandAlone(vector<int> & initComp, vector<double> & inputRate,
int * inputRateMatrix, int * inputUpdateMatrix,
double runTime ,bool sMethod=0, double saveInterval=1)
It calls BCNetwork::loadParameter(...)
to load a biochemical network. stoppingTime
will be determined by runTime
, saveMethod
will be determined by sMethod
. saveInterval
will determine the value of either savePointInterval
or saveTimeInterval
considering which saveMethod
user choose.
The random number generator used by this class is rand48 given in gcc library. Involved function members are
inline void reseedRandom(int seed);
inline double popRandom();
Should other random number generator be used instead the current one. These two member functions can be changed accordingly.
defined in "gillespie.h"
template<typename modelClassName>
class gillespie
This module is built as an stripped version of gillespieStandAlone
class. It works the same way as rungeKutta
class template. A model using this module must inherit the class template, feed the class template an rate determining function member to int modelClassName::*rateDetermine_alias(double *)
. And a reactant updating function member to int (modelClassName::*reactantUpdate_alias)(const double *)
. The algorithm performs a single iteration of Gillespie Algorithm, deciding the time step size of the current iteration and which reaction to take place.
Note that
| Member function name | Requirements |
|---|---|
int modelClassName::*rateDetermine_alias(double *) |
supplied by model, using model's own reactant information to calculate the reaction rate for each reaction. The rate will be pass to the algorithm as a double type pointer given as the function argument. |
int (modelClassName::*reactantUpdate_alias)(const double *) |
supplied by model, algorithm will pass the number(1 or 0)of each reaction taking places during the time interval as a constant double type pointer. The function member will use the array multiplying the updating part of the reaction. Resulting value will be added onto the current reactant amount stored in model. |
type variable_name |
meaning |
|---|---|
bool randomAlgorithm |
the random number generator chosen. 1=mt19937, 0=rand48 |
double iterate();
The function will do one iteration of algorithm. Reactant amounts will be updated by int reactantUpdate(const double *)
, while the time step is to be returned as a double type value.
gillespie();
gillespie(int reactionNumber_alias, int
(modelClassName::*rateDetermine_alias)(double *), int
(modelClassName::*reactantUpdate_alias)(const double *), bool
useMTwister=RDALGORITHM_MT)
Default constructor does nothing. Not used in most scenario.
The second constructor is what is mostly used when loading with Gillespie algorithm, reaction number and the two function member pointer introduced earlier must be provided when inheriting this algorithm module.
In both cases, randomAlgorithm
will be set as RDALGORITHM_MT
, aka, 1
. In the second case, if rand48
is in any case preferred, over-ride useMTwister
with value 0
.
defined in "ODECommon.h"
template<typename modelClassType>
class ODEIVPCommon
This class is a basic class template for all algorithms created for ODE's Initial Value Problem simulation. Currently only Runge-Kutta based simulator is created from it.
modelClassType
is a typename specified by the models that algorithms are applied upon. It is used by member function pointers of the algorithms for proper scope names.
type variable_name |
meaning |
|---|---|
double ht |
current stepsize. For adaptive stepsize algorithms, this value is usually different from ODENetwork::h0 |
int varNumber |
number of variables/ODEs. |
void (modelClassType::*ODEs)(double *, double *) |
member function pointer. Used to point to ODEs function provided by the specific model. First double* point to the returned time derivation, second double* points to where the reactants are stored. |
int (*Normalizer)(double *) |
a normalizer, usually need to be specified for each different problem. Thus by definition it's not bound to the member class. Note that this is a function pointer, only static function can be pointed by it. |
N/A
ODEIVPCommon();
ODEIVPCommon(int sysSize, double initTimeStep,
void (modelClassType::*targetODEs)(double *, double *));
ODEIVPCommon(int sysSize, double initTimeStep,
void (modelClassType::*targetODEs)(double *, double *),
int (*targetNormalizer)(double *));
Three constructors are defined for this class template.
Default constructor does nothing.
ODEIVPCommon(int , double, void (modelClassType::*)(double*, double*));
is used when no normalizer is required. This constructor will load the first parameter as varNumber
, second parameter as the initial value for ht
, and third parameter as the address function pointer void (modelClassType::*ODEs)
pointing to. Normalizer will be specified to int blankNormalizer(double *)
defined in "ODECommon.h". Normalizer can be otherwisely specified to other functions defined by user afterwards.
ODEIVPCommon(int , double, void (modelClassType::*)(double*, double*), int (*)(double *));
is used when normalizer is required. First 3 parameters have the same meaning. And the last parameter is used to specify the pointer pointing to the normalizer function.
defined in "rungeKutta.h"
template<typename modelClassType>
class RKmethod: public ODEIVPCommon<modelClassType>;
This is an algorithm class template using adaptive stepsize Runge-Kutta method for ODEs simulation of initial value problems. This class will do one thing, and one thing alone. Given current values of all components, their value of next time step and the time interval of current iteration will be returned. Users can implement this algorithm in their model for simulation and do any analysis they want with the returned data.
Note that due to the concern of reliable use of this algorithm, this class is not supposed to be directly modified by any means, thus most functions are kept private.
type variable_name |
meaning |
|---|---|
double hMax |
maximum stepsize of iteration, hMax=0 deactivates the limit. |
hMax
is added for situation where a cap of timestep length is necessary. By default hMax=0
, meaning there is no cap value for time step. For any value other than 0
, the maximum time step will be set to that value. User can change the value of hMax
during or after defining an instance of this class template.
double iterator(double * var);
This function takes in the datablock storying current value of the variables pointed by * var
. New value after one step of iteration will be directly written into the datablock * var
pointing to. Time interval for this step of iteration will also be returned as a double value. User can use the time interval to determine the exact time value after this iteration.
RKmethod(maxTimeStep=0);
RKmethod(int sysSize, double initTimeStep,
void (modelClassType::*targetODEs)(double *, double *), maxTimeStep=0) :
ODEIVPCommon<modelClassType>::ODEIVPCommon(sysSize, initTimeStep, targetODEs);
RKmethod(int sysSize, double initTimeStep,
void (modelClassType::*targetODEs)(double *, double *),
void (*targetNormalizer)(double *), maxTimeStep=0):
ODEIVPCommon<modelClassType>::ODEIVPCommon(sysSize, initTimeStep,
targetODEs,targetNormalizer);
The use of the three constructors given by this class template mirror the three constructors of ODEIVPCommon
. The first one only initiate the private variables to their working states; Second constructor is used for the case that no normalizer is required; third constructor is used when a normalizer is required for a successful simulation. If a limit of maximum timestep is required, users can change the value of maxTimeStep
, whose value will be passed on to hMax
during the class initialization.
Class gillespie
described in algorithm classes also falls to this catagory.
defined in "ODEOperation.h"
class ODESimulate : public ODENetwork , public RKmethod<ODESimulate>
This class use Runge-Kutta algorithm to do simulation on IVP of ODEs defined by ODENetwork.
type variable_name |
meaning |
|---|---|
double stoppingTime |
the stopping signal for the simulation |
double saveTimeInterval |
the interval of saving points measured by time interval. |
double lastSavedTime |
the time point in which last saving action has taken places. |
void simulate(string & identifier);
This function will simulate the system and store the result in a file specified by & identifier
(it automatically call the function BCNetwork::fileOpen(string &)
).
void reset();
This function retains the function of BCNetwork::reset()
. It also restore lastSavedTime
to 0. And restore ODEIVPCommon::ht
to the value specified by ODENetwork::h0
.
ODESimulate(vector<double> & initComp, vector<double> & inputRate,
int * inputRateMatrix, int * inputUpdateMatrix,
double initTimeStep, double runTime, double saveInterval) :
ODENetwork(initComp, inputRate, inputRateMatrix, inputUpdateMatrix,
initTimeStep), RKmethod<ODESimulate>(nComp, h0, &ODESimulate::ODETimeDeri);
Notice that no default constructor is defined. This constructor will load a typical biochemical network, and call the constructor of RKmethod
that doesn't use normalizer. Two additional information is loaded to specify stoppingTime
and saveTimeInterval
.
stoppingTime=runTime;
saveTimeInterval=saveInterval;
defined in modelTool.py
with alias modelCreator.py
.
Defines a structure that stores the information of a reaction network, and the operations that applies to it.
| member name | type | member function |
|---|---|---|
reactant |
dict | structure to store reactants and the amount of each of them. Indeces are the hash of corresponding reactant's name. |
reaction |
dict | structure to store reactions, their types and coefficient. Indeces are randomly generated number which is ensured to be unique within the network. |
reactant_const |
dict | indeces(hash of reactant name string) of reactants that are kept constant during scaling |
reaction_const |
dict | indeces(randomly generated, unique number) of reactions that are kept constant during scaling |
insert_new_reaction |
func | insert a new reaction to the network, if there are hashes not exists in the network, prompt to add. |
insert_new_reactant |
func | insert a new reactant to the network. If initial value is not provided, prompt to insert. |
list_reaction |
func | list the reactions with their indeces in human understandable format. If list_target is not provided, list the whole network. |
list_reactant |
func | list the reactants, their hash, reactant name and initial value. |
load |
func | load a network from earlier saved file. (_dev is automatically added, don't add it when specify the modelname) |
save |
func | save the current reaction network into a folder for future loading. (_dev will be automatically added after a user specified model name.) |
export |
func | export the current reaction network into a folder that is recognizable by coarseGrainedxx simulation modules. |
scaling |
func | scale the network by a certain spacial(eta_c_alias ) and time(eta_t_alias ) ratio. Reactions and reactants that are marked constant will not be changed. Reaction rate of non-const-reactions that involves the constant reactants will be adjust accordingly. |
knockout_reactant |
func | knockout the reactants listed in the argument. Involved reactions will be prompted to be removed. Since reactions with undefined reactants are not valid. Not confirming removing the involved reactions will cancel the operation altogether. |
duplicate_reaction |
func | create a duplicate of a currently existing reaction and insert it into the network. Return the index of the newly created reaction. |
Note: 1. Since removing entries from an existing dictionary is well defined in python, we do not build additional methods for reaction knocking out.


For girls
Welcome to Luna. We are a home-grown brand which was started with the intent to make menstrual products more accessible and easily available for women throughout the country. But, thats not it! We also aim to achieve an environment where periods and women hygiene isn’t considered to be a taboo topic and is talked about freely and widely. For that, we offer customisable period kits, good quality period and hygiene products and the most popular feature of our website “SAGE”!!  It can help you with customising your period kit, educating you about the different kind of products available in the market and you can use it as your period tracker as well!! We hope you have a seamless shopping experience at Luna! Happy chumming!!
Sirona Wet Wipes
Sirona wet wipes are alcohol-, paraben-, and artificial-fragrance-free, and are specifically designed for sensitive skin.
Feminax Tablets
Targets period pain in less than 30 minutes! One of our bestseller products. This is a must buy if you experience a lot of cramps! Works for all types of cramps.
Whisper Ultra-night Pads
Ultra-thin sanitary pads with a soft and dry surface for greater comfort. Choose upto 3 sizes in one pack and create a pack that suits your flow.
Enter your information to stay tuned for future products!