text:
Karl Ragnar Knut Gierow, född 2 april 1904 i Helsingborg, död 30 oktober 1982 i Stockholm, var en svensk teaterregissör, författare och översättare. Från 1961 var han ledamot av Svenska Akademien.

Biografi
Gierow var anställd vid Norstedts förlag 1930–1937, var därefter litterär medarbetare vid Radiotjänst 1937–1946, chef för Svenska Dagbladets litteraturavdelning 1946–1951 och chef för Dramaten i Stockholm 1951–1963. Som litteraturrecensent i Svenska Dagbladet undertecknade han stundom artiklar med signaturen K. R. G..

Som Dramatenchef bidrog han till att en hel del ny europeisk – och kontroversiell – dramatik spelades på nationalscenen, bland annat verk av Bertolt Brecht och Jean-Paul Sartre, samt Eugene O'Neills sista stora dramatiska verk (som han, genom hustrun Carlotta O'Neill, fick exklusiv uppföranderätt på): Måne för olycksfödda samt Lång dags färd mot natt år 1956.

Gierow invaldes 1961 i Svenska Akademien på stol nummer 7 och var akademiens ständige sekreterare 1964–1977. Han var också ledamot av Svenska Akademiens Nobelkommitté 1963–1982 (samt dess ordförande 1970–1980). Han ogillade de bländande fotoblixtar som ofta mötte honom då han i egenskap av ständig sekreterare årligen tillkännagav nobelpristagaren i litteratur i Börshuset; därför bar han flera gånger solglasögon vid tillkännagivandet.

Somrarna tillbringades i Villa Sjörröd, Hästveda utom senare år då han vistades på Dag Hammarskjölds Backåkra.

Gierow skrev lyrik och versdramer. Till stadsfullmäktiges 75-årsjubileum i Helsingborg år 1938 skrev han Sång till staden, där en av versraderna lyder: "Till döddagar skall jag minnas, hur det blåser i Hälsingborg; Till barken almarna skinnas av vädret kring Nya Torg." Han skrev även schlagertexter och var under hela sin chefstid samtidigt verksam som regissör på Dramaten.

Gierows gravvård återfinns på Donationskyrkogården i Helsingborg. Han var son till teologen och folkskoleinspektören Arvid Gierow, bror till överbibliotekarie Krister Gierow och farbror till antikvetaren Pär Göran Gierow.

Bibliografi
Poesi
 Solen lyser [dikter] (Bonnier, 1925)
 Den gyllene ungdomen: dikter (Norstedt, 1928)
 Ödletid: dikter (Norstedt, 1937)
 Vid askens rötter: dikter (Norstedt, 1940)
 Om livet är dig kärt: dikter (Norstedt, 1963)
 Soluret och urnan (1966)
 Skall jag taga vara på min broder?: tre dikter (Norstedt, 1968)
 Ut mot udden: ett tjog dikter från femtio år (Norstedt, 1977)
 Innan klockan slagit noll: dikter (Norstedt, 1978)
 Kvar på bryggan: två dussin valda dikter, ett dussin nya (Norstedt, 1981)
 I daggkåpans mantelfåll: nya dikter (Norstedt, 1983)

Pjäser
 Rovdjuret "Homo homini lupus": skådespel i fyra akter (Norstedt, 1941)
 Helgonsaga: skådespel i tre akter (Norstedt, 1943)
 Av hjärtans lust: komedi i tre akter (Norstedt, 1944) (filmatiserad 1960, se vidare Av hjärtans lust)
 Färjstället: skådespel i tre akter (Norstedt, 1946)
 Domkyrkospel (Norstedt, 1946)
 Etyd i klassisk stil (otryckt pjäs för Radioteatern 1959)
 Cembalo: skådespel (Norstedt, 1961)
 Den fjärde vise mannen: triptyk med förspel (Norstedt, 1970)

Essäer m.m.
 1914-1918 in memoriam (Bonnier, 1939)
 Mina utflykter (Norstedt, 1950)
 Introduktioner till Eugene O'Neills dramatik (Sveriges Radio, 1958)
 Hjalmar Gullberg: inträdestal i Svenska akademien (Norstedt, 1961)
 Minne av Abraham Niclas Clewberg Edelcrantz (Norstedt, 1964)
 Benjamin Höijer (Norstedt, 1971)
 Europa och tjuren: femton essayer (Norstedt, 1972)
 Johan Henrik Thomander (Norstedt, 1975)
 Tal om cigarr-rökning (Cigarrklubben Gustaf V, 1989)

Översättningar (urval)
 Storm Jameson: Elva och tjugufem kvar (A day off) (Norstedt, 1933)
 G. K. Chesterton: Charles Dickens (Charles Dickens) (Norstedt, 1933)
 Henrik Ibsen: Peer Gynt (Peer Gynt) (Radiotjänst, 1935)
 Maxwell Anderson: Mayerlingdramat: skådespel (Masque of kings) (Bonnier, 1938)
 Eric Linklater: De ointagliga kvinnorna (The impregnable women) (Norstedt, 1939)
 Djuna Barnes: Växelsången (The antiphon) (översatt tillsammans med Dag Hammarskjöld, Norstedt, 1961)
 William Shakespeare: Romeo och Julia (Romeo and Juliet) (otryckt översättning)
 Christopher Marlowe: Den tragiska historien om Doktor Faustus (Almqvist & Wiksell, 1964)

Filmmanus

1945 – Galgmannen (En midvintersaga)
1944 – Kungajakt
1944 – Snöstormen
1943 – Det brinner en eld
1943 – Elvira Madigan

Litteratur
 Rolf Arvidsson: Karl Ragnar Gierow: bibliografi 1921-1977 (Norstedt, 1978)
 Knut Ahnlund: Karl Ragnar Gierow: inträdestal i Svenska akademien (Norstedt, 1983)

Utmärkelser, ledamotskap och priser
  Kommendör med storkors av Nordstjärneorden, KmstkNO, 3 december 1974.
 Ledamot av Vetenskapssocieteten i Lund (LVSL)
 Hedersdoktor 1964
 Bellmanpriset 1977
 Guldskeppet 1977

Källor

Externa länkar

www.karlragnargierow.se

Svenska Akademiens ständiga sekreterare
Ledamöter av Svenska Akademien
Ledamöter av Vetenskapssocieteten i Lund
Svenskspråkiga författare
Svenska författare
Svenska översättare under 1900-talet
Svenska manusförfattare under 1900-talet
Svenska teaterregissörer
Översättare från engelska
Översättare från norska
Kommendörer med stora korset av Nordstjärneorden
Författare från Helsingborg
Gravsatta på Donationskyrkogården
Födda 1904
Avlidna 1982
Män


text:
Archive for June 3rd, 2009
DorobekInsider: Former GSAer John C. Johnson wins ACT/IAC's 2009 Franke award
There are a lot of awards out there. One of the more prestigious of those awards is the John J. Franke Jr. award, given out by the American Council on Technology and the Industry Advisory Council (ACT/IAC) each year at the Management of Change conference.
The year's winner was John C. Johnson, who recently retired from his post as GSA Federal Acquisition Service's Assistant Commissioner for the Federal Acquisition Service's Integrated Technology Services, which oversees some of the government's biggest and most important contracts including the GSA schedule contracts, GSA's governmentwide telecommunications contracts such as Networx , and GSA's governmentwide acquisition vehicles , including the Alliant mega-contract. Johnson joined Deep Water Point Consulting.
Ira Hobbs, the former Treasury Department CIO and the 2003 winner of the Franke award, did a remarkable job setting the tone. (Hobbs so often does a remarkable job setting the tone.) Hobbs noted that he had the pleasure of working forFranke while he was at the Agriculture Department. Franke had battled with cancer, but "he did so in a way that gave strength to other people dealing with the same disease."
Hobbs noted that Franke made mentoring a priority. When Hobbs as a presidential management intern and Franke was the assistant secretary for administration — "back when they were God like figures" — Franke would invite the interns to a regular lunch and he would talk to them about their experiences and challenges. Hobbs noted that the room was filled with people were were trying to make it in the world, andFranke — in words and in actions — illustrated that strong leaders focus on the people who help you be successful.
Karen Evans, the former administrator of e-government and information technology at the Office of Management and Budget and the 2008 Franke award winner, noted that Johnson had helped with many of the big initiatives, even incorporating security provisions into the Networx telecommunication contract.
Johnson called the recognition a "tremendous honor" and the culmination of a 34 year government career. "This symbolizes what we have accomplished together."
I had Johnson on Federal News Radio's Government IT Solutions Spotlight just before he left government — an exit-interview, if you will. You can hear that here.
Read the ACT/IAC press release here [Scribd Flash verion] or here [PDF].
More on the Franke award from ACT/IAC:
The award is presented each year in memory of John J. Franke, an Assistant Secretary for Management in the Department of Agriculture under President Reagan, and later the first Director of the Federal Quality Institute. He started as a successful small businessman in the State of Kansas, served as County Commissioner in Johnson County, and later moved into regional government in Kansas City. Mr. Franke died in 1991 after a courageous battle with cancer.
Mr. Franke is remembered as an appointee who recognized the key role of information systems in the management of government, and his interest in the information management community extended beyond his own work. He encouraged his managers to take an active role in government-wide organizations such as ACT, participated in conferences to learn how information systems could help make government more effective, and challenged those in the field to do things smarter and faster.
Previous winners have included:
2003: Ira Hobbs
2006: Dave Winnergren
2007: Kevin Carroll
2008: Karen Evans
If there is a more comprehensive list, let me know and I'll get it posted.
Posted in awards, Circuit, community, GSA, procurement, Technology
DorobekInsider: How do you build a better Web site? One member of Congress tries crowdsourcing
Rep. Mike Honda (D-CA) is looking to redesign his Web site. How does one go about doing that? Crowdsourcing.
Honda details the thinking behind it on his blog:
Recently, I announced the launch of a new pioneering project to improve civic engagement in Congress via crowdSPRING. I will be redesigning my website – using a technique called crowd-sourcing – to lead the way in making government sites more transparent and accessible to the public.
The project allows designers to mock up multiple layouts for consideration by you, my constituents. The final design will be chosen based on votes, design functionality, usability, and other criteria. I believe that this crowd-sourcing initiative will usher in a new era of government transparency. Many government websites have good content, but the content is often very hard to find. We are giving power to you, and democratizing the way we interact with the public.
My goal as your Member of Congress is to serve you first and foremost. This crowd-sourcing initiative ensures that I am meeting your needs on your terms by allowing an unprecedented level of access into the design process of a government website.
The purpose of the website redesign is to move America closer to Government 2.0, where the public's ability to access and provide advice to Members of Congress is enhanced by new technology and new online participation. As many of you know, I am very active through Twitter, Facebook, and my blog. I intend to make my new site be an example for other member sites to follow. Congress must take advantage of Web 2.0 technologies, to transform the relationship between citizens and government. Instead of viewing the public as a customer for services, I believe that we should empower citizens to become our partners in shaping the future of our nation.
The project has gone live, you can view the entries by clicking here.
I would love to hear your comments about this initiative. You can leave them on my blog here.
I will be posting more information soon about the voting process once we begin recieving entries for consideration.
This has just launched, but… Find the specific details about this initiative here.
What a fascinating idea — and how fun will it be to watch this as it evolves.
Posted in Congress, EGov, Government 2.0, innovation, Technology, Web 2.0, Web sites

redpajama_set_name: RedPajamaCommonCrawl


text:
{- |
= Password Hashing
== Purpose
Secret keys used to encrypt or sign confidential data have to be
chosen from a very large keyspace. However, passwords are usually
short, human-generated strings, making dictionary attacks practical.

The 'deriveKey' operation derives a secret key of any size from a password
and a 'Salt'.

* The generated key has the size defined by the application, no matter
  what the password length is.
* The same password hashed with same parameters will always produce
  the same key.
* The same password hashed with different salts will produce different
  keys.
* The function deriving a key from a password and a salt is CPU
  intensive and intentionally requires a fair amount of memory.
  Therefore, it mitigates brute-force attacks by requiring a significant
  effort to verify each password.

Common use cases:

* Protecting an on-disk secret key with a password,
* Password storage, or rather: storing what it takes to verify a
  password without having to store the actual password.
-}

module Crypto.Sodium.PwHash
       ( -- * Constants
         saltBytes -- | Number of bytes in a 'Salt'.
       , hashedPasswordBytes -- | Number of bytes in a 'HashedPassword'.
       , opsLimitInteractive -- | Safe base line for 'OpsLimit'.
       , opsLimitSensitive -- | 'OpsLimit' for highly sensitive data.
       , memLimitInteractive -- | Safe base line for 'MemLimit'.
       , memLimitSensitive -- | 'MemLimit' for highly sensitive data.

       -- * Types
       , OpsLimit (..) -- | Maximum amount of computations to perform.
                       -- Raising this number will make the calling function
                       -- require more CPU cycles to compute a key.
       , MemLimit (..) -- | Maximum amount of RAM that the calling function
                       -- will use, in bytes. It is highly recommended to allow
                       -- the function to use at least 16 megabytes.
       , Salt -- | Unpredictable 'Salt' for key derivation.
       , mkSalt -- | Smart constructor for 'Salt'. Verifies that the length of
                -- the parameter is 'saltBytes'.
       , unSalt -- | Returns the contents of a 'Salt'.
       , HashedPassword -- | An ASCII-encoded NULL-terminated string that
                        -- includes:
                        --
                        -- * The result of a memory-hard, CPU-intensive function
                        --   applied to a password
                        -- * The automatically generated salt used for the
                        --   computation
                        -- * The other parameters needed to verify the password,
                        --   'OpsLimit' and 'MemLimit'.
       , mkHashedPassword -- | Smart constructor for 'HashedPassword'.
                          -- Verifies that the length of the parameter is
                          -- 'hashedPasswordBytes'.
       , unHashedPassword -- | Returns the contents of a 'HashedPassword'.

         -- * Salt Generation
       , randomSalt -- | Randomly generates a 'Salt'.

         -- * Key Derivation
       , deriveKey -- | Derives a key of a certain length from a
                   -- password and a 'Salt'.
                   -- Returns 'Nothing' if 'deriveKey' couldn't complete
                   -- successfully, usually because the operating system
                   -- refused to allocate the requested amount of memory.

         -- * Password Hashing
       , hashPassword -- | Derives a 'HashedPassword' from a password
                      -- with a randomly generated 'Salt'.
                      -- Returns 'Nothing' if it couldn't complete successfully,
                      -- usually because the operating system refused to
                      -- allocate the requested amount of memory.
       , verifyPassword -- | Verifies that a 'HashedPassword' is a valid
                        -- password verification string (as generated by 'hashPassword')
                        -- for a password.
       ) where

import           Crypto.Sodium.PwHash.ScryptSalsa208Sha256

redpajama_set_name: RedPajamaGithub


text:
Ian Ballantine
Ian Keith Ballantine was a publisher who founded and published the paperback line of Ballantine Books (1952 to 1974) with his wife, Betty.
In 1939, Ian Ballantine initiated the distribution of Penguin Books in the United States. As a team, the Ballantines were involved in the formation of Bantam Books in 1945, and Ian was the first president of Bantam (1945 to 1952).
Ballantine Books was one of the earliest publishers of SF paperback originals, with writers that included Arthur C. Clarke, Chad Oliver, and Frederik Pohl. During the 1960s, Ballantine published the first authorized paperback editions of Tolkien's books. In the 1970s, Lin Carter edited their Ballantine Adult Fantasy series that included works by H. P. Lovecraft.
After Ballantine Books was acquired by Random House in 1973, the Ballantines became freelance consulting editors and publishers. Ian Ballantine died of a heart attack in 1995 at the age of 79.
Awards, Honors and GoHships:
1975 — OakLaCon, World Fantasy Award
1979 — LepreCon 5
1980 — Coveted Balrog Award, Invisible Little Man Award
1984 — World Fantasy Special Award, Best Non Fiction Book Hugo nominee
1985 — Hatcon 3, Nebula Award
1989 — Noreascon 3 with Betty
1991 — Lunacon 34
2008 — Science Fiction Hall of Fame
RE SFE Wikipedia File770
Ansible ISFDB FF http://www.google.com (IA) Website


Light or dark, fire or ice – which will you choose? In Dragon Sisters, you can have both! Join the two beautiful sisters as they command their dragons to reward you with Random Wilds or Stacked Wilds during their respective Respins. Which dragon will reign supreme?
Dragon Sisters features 5 reels and 3 rows, but on two separate screens. That's right; each sister has their own 5×3 reel that spins with each round. The game symbols are almost identical on both screens – with colorful gems as the low-paying symbols and a sword, spear, shield, and crown as the high-paying symbols.
The only difference is the presence of the two sisters and their respective dragons. On the top screen, The Dark Sister and her Red Dragon find their home. The Dark Sister is the highest-paying symbol there. On the other hand, the bottom screen holds the Light Sister and her Blue Dragon. Like the Dark Sister, the Light Sister is the highest-paying symbol on the bottom screen.
The Wild Symbol appears on both the top and bottom screen during regular gameplay. It can substitute for all regular symbols, including the Dark and Light Sisters. The only symbols it can't replace are the Red and Blue Dragons!
Additionally, the Wild Symbol rewards its own high payout when 3 or more form a part of any of the 24 fixed paylines.
Whenever the Red Dragon appears on the top screen, it breathes a trail of fire onto the reel directly below it on the bottom screen. When the fire dies down, a full stack of Wild Symbols will appear in its place.
With the Stacked Wilds stuck in place, the bottom reels will respin.
The Blue Dragon on the bottom reel will trigger a respin as well, but this time of the reels in the top screen. When the Blue Dragon appears, it'll shoot up to 3 balls of blue fire onto random positions on the top screen. When the fire fades, Wild symbols will appear in their place.
The Random Wilds will remain in place and the reels in the top screen will spin again.
Respins will continue until no more Dragons appear.
Dragon Sisters gives you twice the chance to win with its two simultaneous game screens. With the fantasy-themed background music and graphics, it's certainly a game that'll take you back to the medieval times of princesses, knights, and dragons. Play Dragon Sisters today!


Thanks to a technique that reveals galaxies in 3D, astronomers can now show that many galaxies have been wrongly classified. Davor Krajnovi\'c argues that the classification scheme proposed 85 years ago by Edwin Hubble now needs to be revised.
The edge-on foreground galaxy (horizontal) and the background galaxy (Vertical). For full caption, please refer to the end of the article. Credit: Jayanne English (U. of Manitoba), Judith Irwin (Queen's U.), Richard Rand (U. of New Mexico) and collaborators in the CHANG-ES consortium, NRAO VLA, NASA WISE & Spitzer missions, NOAO, and SDSS.
Astronomers studying gas halos around nearby galaxies were surprised when detailed studies with the National Science Foundation's Karl G. Jansky Very Large Array (VLA) showed that one of their subjects is not a single galaxy, but rather two, nearly perfectly superimposed on the sky to masquerade as one. The discovery allowed them to use the alignment to learn otherwise-unobtainable facts about the nearer galaxy.
As part of a study of 35 galaxies, the astronomers observed one called UGC 10288, a spiral galaxy more than 100 million light-years distant that appears edge-on as seen from Earth. Their multiple VLA observations in 2011 and 2012 produced the best radio-telescope images of that galaxy ever made. The detailed images surprisingly revealed a more-distant galaxy, with strong radio emission, almost directly behind UGC 10288. In previous images, the two galaxies had been blended together.
The background galaxy is nearly 7 billion light-years from Earth.
"This changed the picture, quite literally," said Judith Irwin, of Queen's University in Ontario, Canada. "It changed our understanding of the characteristics of UGC 10288, but also gave us an unexpected new tool for learning more about that galaxy," Irwin added. The alignment of a foreground galaxy with such a strongly-emitting background galaxy with extended jets probably is the first such alignment found, the astronomers said.
The first insight gleaned from the improved images was that UGC 10288 is not forming stars as rapidly as the astronomers first thought. This is because much of the radio emission in the previous, blended images came from the background galaxy.
The new images also showed that the gas in the galaxy's "outskirts," high above its spiral disk of stars, is not a single, smooth halo-like envelope, but instead forms smaller, discrete features. One of these features is arc-like, rising more than 11,000 light-years above the disk.
The background galaxy, and the fact that it is aligned with its radio jets perpendicular to UGC 10288's disk, provides a valuable means of studying the nearer galaxy. "We can use the radio waves from the background galaxy, coming through the nearer one, as a way to measure the properties of the nearer galaxy," said Jayanne English, of the University of Manitoba.
Preliminary use of the more-distant galaxy in this manner has given the scientists some magnetic-field measurements of different portions of UGC 10288. The researchers plan to do additional analysis of their data to make more such measurements.
"We're getting a nice scientific reward from the unexpected discovery of the background galaxy," Irwin said. "Ironically, we would not have included UGC 10288 in our original study if its radio brightness had not been boosted by the background galaxy in the earlier images," she added.
Irwin and English worked with an international team of astronomers from North America, Europe, and India who are part of the Continuum Halos in Nearby Galaxies — an EVLA Survey (CHANG-ES) consortium. The scientists reported their findings in the Astronomical Journal.
Galaxies come in two main types: spirals galaxies, like our Milky Way. and elliptical galaxies, which don't contain such intricate structures. Some of the largest galaxies in the Universe are ellipticals, with some containing many trillions of and weighing in at thousands of times the mass of our own Milky Way. However, there has long been a question over how they built up such a large collection of stars, as they appear to have stopped forming them long ago. One proposal is that they started of relatively large and gradually built up by consuming of lots of smaller galaxies. Another idea is that they are the result of just a couple of two large galaxies colliding – a so-called "major merger".
The latest discovery was found as a bright red dot in a Herschel image, just one of thousands in a large area of sky studied in the constellation of Cetus the Whale, and goes by the name "HXMM01". Detailed observations from ground-based telescopes showed that it is was a pair of galaxies, just 60,000 light years apart and in the process of merging together. These galaxies themselves are relatively large, each containing several times as many stars as the Milky Way, but are all but invisible at optical wavelengths, due to thick, obsuring clouds of gas and dust. Herschel, which observed in the far-infrared, is able to see through this dust to the action taking place within.
The galaxies are seen as they were 11 billion years ago, when the Universe was only around 3 billion years old, and the expectation is that they would have merged to form one massive galaxy over the course of the next few hundred million years or so. "These galaxies entered a feeding frenzy, which would have quickly exhausted the food supply in the following hundreds of millions of years, leading to the nrely-forming galaxy's slow starvation" commented Hai Hu, of University of Irvine, California, and the lead author of the latest paper.
These are forming stars at a prolific rate, equivalent to 2000 suns being born every year – around a thousand times faster than our Milky Way is today. The cause of this rapid starbirth is the huge reservoirs of gas and dust in the galaxies, roughly equal to the mass of the stars currently there. Although it is unclear how they built up such a massive gas supply the expectation is that in a billion year or so, when most of the gas has been converted into stars, the resulting mammoth galaxy will contain the equivalent of 400 billion suns – not far off the most massive galaxies known to exist.
The fact that this is such a quick event, at least by cosmological standards, is why snap-shots of massive galaxies in the process of merging are so hard to find, with only half a dozen or so seen so far at this early stage in the Universe's evolution. Despite their rarity, such mergers of massive galaxies could play a key role in the formation of the most massive elliptical galaxies we see around us today.
Visible as a small, sparkling hook in the dark sky, this beautiful object is known as J082354.96+280621.6, or J082354.96 for short. It is a starburst galaxy, so named because of the incredibly (and unusually) high rate of star formation occurring within it.
One way in which astronomers probe the nature and structure of galaxies like this is by observing the behavior of their dust and gas components; in particular, the Lyman-alpha emission. This occurs when electrons within a hydrogen atom fall from a higher energy level to a lower one, emitting light as they do so. This emission is interesting because this light leaves its host galaxy only after extensive scattering in the nearby gas — meaning that this light can be used as a pretty direct probe of what a galaxy is made up of.
The study of this Lyman-alpha emission is common in very distant galaxies, but now a study named LARS (Lyman Alpha Reference Sample) is investigating the same effect in galaxies that are closer by. Astronomers chose fourteen galaxies, including this one, and used spectroscopy and imaging to see what was happening within them. They found that these Lyman-alpha photons can travel much further if a galaxy has less dust — meaning that we can use this emission to infer how dusty the source galaxy is.


text:
/*
 * Changes for GemFireXD distributed data platform (some marked by "GemStone changes")
 *
 * Portions Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License. You
 * may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License. See accompanying
 * LICENSE file.
 */

package com.pivotal.gemfirexd.internal.iapi.store.access;

import com.gemstone.gnu.trove.THashMap;
import com.pivotal.gemfirexd.internal.engine.Misc;
import com.pivotal.gemfirexd.internal.engine.GfxdConstants;
import com.pivotal.gemfirexd.internal.engine.distributed.metadata.RegionAndKey;
import com.pivotal.gemfirexd.internal.engine.distributed.utils.GemFireXDUtils;
import com.pivotal.gemfirexd.internal.engine.sql.conn.GfxdHeapThresholdListener;
import com.pivotal.gemfirexd.internal.iapi.error.StandardException;
import com.pivotal.gemfirexd.internal.iapi.services.cache.ClassSize;
import com.pivotal.gemfirexd.internal.iapi.services.sanity.SanityManager;
import com.pivotal.gemfirexd.internal.iapi.sql.execute.ExecRow;
import com.pivotal.gemfirexd.internal.iapi.types.CloneableObject;
import com.pivotal.gemfirexd.internal.iapi.types.DataValueDescriptor;
import com.pivotal.gemfirexd.internal.shared.common.reference.SQLState;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.NoSuchElementException;

/**
A BackingStoreHashtable is a utility class which will store a set of rows into
an in memory hash table, or overflow the hash table to a tempory on disk
structure.

All rows must contain the same number of columns, and the column at position
N of all the rows must have the same format id.  If the BackingStoreHashtable needs to be
overflowed to disk, then an arbitrary row will be chosen and used as a template
for creating the underlying overflow container.

The hash table will be built logically as follows (actual implementation
may differ).  The important points are that the hash value is the standard
java hash value on the row[key_column_numbers[0], if key_column_numbers.length is 1,
or row[key_column_numbers[0, 1, ...]] if key_column_numbers.length > 1,
and that duplicate detection is done by the standard java duplicate detection provided by
java.util.Hashtable.

import java.util.Hashtable;

hash_table = new Hashtable();

Object[] row;
boolean  needsToClone = rowSource.needsToClone();

while((row = rowSource.getNextRowFromRowSource()) != null)
{
    if (needsToClone)
        row = clone_row_from_row(row);

    Object key = KeyHasher.buildHashKey(row, key_column_numbers);

    if ((duplicate_value =
        hash_table.put(key, row)) != null)
    {
        Vector row_vec;

        // inserted a duplicate
        if ((duplicate_value instanceof vector))
        {
            row_vec = (Vector) duplicate_value;
        }
        else
        {
            // allocate vector to hold duplicates
            row_vec = new Vector(2);

            // insert original row into vector
            row_vec.addElement(duplicate_value);

            // put the vector as the data rather than the row
            hash_table.put(key, row_vec);
        }

        // insert new row into vector
        row_vec.addElement(row);
    }
}

**/

public class BackingStoreHashtable
{

    /**************************************************************************
     * Fields of the class
     **************************************************************************
     */
    private TransactionController tc;
    private THashMap     hash_table;
    private int[]       key_column_numbers;
    private boolean     remove_duplicates;
	private boolean		skipNullKeyColumns;
    private Properties  auxillary_runtimestats;
	protected RowSource	row_source;
    /* If max_inmemory_rowcnt > 0 then use that to decide when to spill to disk.
     * Otherwise compute max_inmemory_size based on the JVM memory size when the BackingStoreHashtable
     * is constructed and use that to decide when to spill to disk.
     */
    private long max_inmemory_rowcnt;
    private long inmemory_rowcnt;
    private long max_inmemory_size;
    private boolean keepAfterCommit;

    /**
     * The estimated number of bytes used by ArrayList(0)
     */
    private final static int ARRAY_LIST_SIZE =
        ClassSize.estimateBaseFromCatalog(ArrayList.class);

    private DiskHashtable diskHashtable;

// GemStone changes BEGIN
    private final GfxdHeapThresholdListener thresholdListener = Misc
        .getMemStore().thresholdListener();

// GemStone changes END
    /**************************************************************************
     * Constructors for This class:
     **************************************************************************
     */
    private BackingStoreHashtable(){}

    /**
     * Create the BackingStoreHashtable from a row source.
     *

     * This routine drains the RowSource.  The performance characteristics
     * depends on the number of rows inserted and the parameters to the
     * constructor.
     *

     * If the number of rows is <= "max_inmemory_rowcnt", then the rows are
     * inserted into a java.util.HashMap. In this case no
     * TransactionController is necessary, a "null" tc is valid.
     *

     * If the number of rows is > "max_inmemory_rowcnt", then the rows will
     * be all placed in some sort of Access temporary file on disk.  This
     * case requires a valid TransactionController.
     *
     * @param tc                An open TransactionController to be used if the
     *                          hash table needs to overflow to disk.
     *
     * @param row_source        RowSource to read rows from.
     *
     * @param key_column_numbers The column numbers of the columns in the
     *                          scan result row to be the key to the HashMap.
     *                          "0" is the first column in the scan result
     *                          row (which may be different than the first
     *                          row in the table of the scan).
     *
     * @param remove_duplicates Should the HashMap automatically remove
     *                          duplicates, or should it create the list of
     *                          duplicates?
     *
     * @param estimated_rowcnt  The estimated number of rows in the hash table.
     *                          Pass in -1 if there is no estimate.
     *
     * @param max_inmemory_rowcnt
     *                          The maximum number of rows to insert into the
     *                          inmemory Hash table before overflowing to disk.
     *                          Pass in -1 if there is no maximum.
     *
     * @param initialCapacity   If not "-1" used to initialize the java HashMap
     *
     * @param loadFactor        If not "-1" used to initialize the java HashMap
	 *
	 * @param skipNullKeyColumns	Skip rows with a null key column, if true.
     *
     * @param keepAfterCommit If true the hash table is kept after a commit,
     *                        if false the hash table is dropped on the next commit.
     *
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public BackingStoreHashtable(
    TransactionController   tc,
    RowSource               row_source,
    int[]                   key_column_numbers,
    boolean                 remove_duplicates,
    long                    estimated_rowcnt,
    long                    max_inmemory_rowcnt,
    int                     initialCapacity,
    float                   loadFactor,
        boolean                                 skipNullKeyColumns,
    boolean                 keepAfterCommit)
        throws StandardException
    {
        this(tc, row_source, key_column_numbers, remove_duplicates,
            estimated_rowcnt, max_inmemory_rowcnt, initialCapacity, loadFactor,
            skipNullKeyColumns, keepAfterCommit, true);
    }
    /*
     * Added parameter
     * @param fillUpHashTable Either fill-up Hash table or leave empty
     */
    protected BackingStoreHashtable(
    TransactionController   tc,
    RowSource               row_source,
    int[]                   key_column_numbers,
    boolean                 remove_duplicates,
    long                    estimated_rowcnt,
    long                    max_inmemory_rowcnt,
    int                     initialCapacity,
    float                   loadFactor,
	boolean					skipNullKeyColumns,
    boolean                 keepAfterCommit,
    boolean                 fillUpHashTable)
        throws StandardException
    {
        this.key_column_numbers    = key_column_numbers;
        this.remove_duplicates    = remove_duplicates;
		this.row_source			   = row_source;
		this.skipNullKeyColumns	   = skipNullKeyColumns;
        this.max_inmemory_rowcnt = max_inmemory_rowcnt;
        if( max_inmemory_rowcnt > 0)
            max_inmemory_size = Long.MAX_VALUE;
        else
            max_inmemory_size = Runtime.getRuntime().totalMemory()/100;
        this.tc = tc;
        this.keepAfterCommit = keepAfterCommit;

        // use passed in capacity and loadfactor if not -1, you must specify
        // capacity if you want to specify loadfactor.
        if (initialCapacity != -1)
        {
            hash_table =
                ((loadFactor == -1) ?
                     new THashMap(initialCapacity) :
                     new THashMap(initialCapacity, loadFactor * 0.8f));
        }
        else
        {
            /* We want to create the hash table based on the estimated row
             * count if a) we have an estimated row count (i.e. it's greater
             * than zero) and b) we think we can create a hash table to
             * hold the estimated row count without running out of memory.
             * The check for "b" is required because, for deeply nested
             * queries and/or queries with a high number of tables in
             * their FROM lists, the optimizer can end up calculating
             * some very high row count estimates--even up to the point of
             * Double.POSITIVE_INFINITY (see DERBY-1259 for an explanation
             * of how that can happen).  In that case any attempts to
             * create a hash table of size estimated_rowcnt can cause
             * OutOfMemory errors when we try to create the hash table.
             * So as a "red flag" for that kind of situation, we check to
             * see if the estimated row count is greater than the max
             * in-memory size for this table.  Unit-wise this comparison
             * is relatively meaningless: rows vs bytes.  But if our
             * estimated row count is greater than the max number of
             * in-memory bytes that we're allowed to consume, then
             * it's very likely that creating a hash table with a capacity
             * of estimated_rowcnt will lead to memory problems.  So in
             * that particular case we leave hash_table null here and
             * initialize it further below, using the estimated in-memory
             * size of the first row to figure out what a reasonable size
             * for the hash table might be.
             */
            hash_table =
                (((estimated_rowcnt <= 0) || (row_source == null)) ?
                     new THashMap() :
                     (estimated_rowcnt < max_inmemory_size) ?
                         new THashMap((int) estimated_rowcnt) :
                         null);
        }

        if (row_source != null && fillUpHashTable)
        {
            boolean needsToClone = row_source.needsToClone();

            DataValueDescriptor[] row;
            while ((row = getNextRowFromRowSource()) != null)
            {
                // If we haven't initialized the hash_table yet then that's
                // because a hash table with capacity estimated_rowcnt would
                // probably cause memory problems.  So look at the first row
                // that we found and use that to create the hash table with
                // an initial capacity such that, if it was completely full,
                // it would still satisfy the max_inmemory condition.  Note
                // that this isn't a hard limit--the hash table can grow if
                // needed.
                if (hash_table == null)
                {
                    // Check to see how much memory we think the first row
                    // is going to take, and then use that to set the initial
                    // capacity of the hash table.
                    double rowUsage = getEstimatedMemUsage(row);
                    hash_table =
                        new THashMap((int)(max_inmemory_size / rowUsage));
                }
                // Gemstone changes BEGIN
                if (GemFireXDUtils.TraceOuterJoin || GemFireXDUtils.TraceNCJIter) {
                  SanityManager.DEBUG_PRINT(GfxdConstants.TRACE_OUTERJOIN_MERGING,
                      "BackingStoreHashTable::BackingStoreHashtable calling add_row_to_hash_table for row = "
                          + Arrays.toString(row) + ", needsToclone: " + needsToClone
                          + " and rak: " + null);
                }
                add_row_to_hash_table(row, needsToClone, null);
             // Gemstone changes END
            }
        }

        // In the (unlikely) event that we received a "red flag" estimated_rowcnt
        // that is too big (see comments above), it's possible that, if row_source
        // was null or else didn't have any rows, hash_table could still be null
        // at this point.  So we initialize it to an empty hashtable (representing
        // an empty result set) so that calls to other methods on this
        // BackingStoreHashtable (ex. "size()") will have a working hash_table
        // on which to operate.
        if (hash_table == null)
            hash_table = new THashMap();
    }

    /**************************************************************************
     * Private/Protected methods of This class:
     **************************************************************************
     */

	/**
	 * Call method to either get next row or next row with non-null
	 * key columns.
	 *
     *
	 * @exception  StandardException  Standard exception policy.
	 */
	protected DataValueDescriptor[] getNextRowFromRowSource()
		throws StandardException
	{
	        ExecRow r = row_source.getNextRowFromRowSource();
		DataValueDescriptor[] row = r != null ? r.getRowArray() : null;

		if (skipNullKeyColumns)
		{
			while (row != null)
			{
				// Are any key columns null?
				int index = 0;
				for ( ; index < key_column_numbers.length; index++)
				{
					if (row[key_column_numbers[index]].isNull())
					{
						break;
					}
				}
				// No null key columns
				if (index == key_column_numbers.length)
				{
					return row;
				}
				// 1 or more null key columns
// GemStone changes BEGIN
				r = row_source.getNextRowFromRowSource();
				row = r != null ? r.getRowArray() : null;
				/* (original code)
				row = row_source.getNextRowFromRowSource().getRowArray();
				*/
// GemStone changes END
			}
		}
		return row;
	}

    /**
     * Return a cloned copy of the row.
     *
	 * @return The cloned row row to use.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    private static DataValueDescriptor[] cloneRow(DataValueDescriptor[] old_row)
        throws StandardException
    {
        DataValueDescriptor[] new_row = new DataValueDescriptor[old_row.length];

		// the only difference between getClone and cloneObject is cloneObject does
		// not objectify a stream.  We use getClone here.  Beetle 4896.
        for (int i = 0; i < old_row.length; i++)
        {
            if( old_row[i] != null)
                new_row[i] = old_row[i].getClone();
        }

        return(new_row);
    }

    /**
     * Return a shallow cloned row
     *
     * @return The cloned row row to use.
     *
     * @exception  StandardException  Standard exception policy.
     **/
    static DataValueDescriptor[] shallowCloneRow(DataValueDescriptor[] old_row)
        throws StandardException
    {
        DataValueDescriptor[] new_row = new DataValueDescriptor[old_row.length];
        // the only difference between getClone and cloneObject is cloneObject does
        // not objectify a stream.  We use cloneObject here.  DERBY-802
        for (int i = 0; i < old_row.length; i++)
        {
            if( old_row[i] != null)
                new_row[i] = (DataValueDescriptor)
                    ((CloneableObject) old_row[i]).cloneObject();
        }

        return(new_row);
    }

    /**
     * Do the work to add one row to the hash table.
     *

     *
     * @param row               Row to add to the hash table.
     * @param needsToClone      If the row needs to be cloned
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    // Gemstone changes BEGIN
    protected void add_row_to_hash_table(DataValueDescriptor[] row, boolean needsToClone, RegionAndKey rak)
 // Gemstone changes END
		throws StandardException
    {
      // Gemstone changes BEGIN
        if (GemFireXDUtils.TraceOuterJoin || GemFireXDUtils.TraceNCJIter) {
          SanityManager.DEBUG_PRINT(GfxdConstants.TRACE_OUTERJOIN_MERGING,
              "BackingStoreHashTable::add_row_to_hash_table called for row: "
                  + Arrays.toString(row) + " and rak: " + rak);
        }
      // Gemstone changes END

        if (spillToDisk(row))
            return;

        if (needsToClone)
        {
            row = cloneRow(row);
        }
        Object key = KeyHasher.buildHashKey(row, key_column_numbers);
        Object  duplicate_value = null;

        if ((duplicate_value = hash_table.put(key, row)) == null) {
          // Gemstone changes BEGIN
          if (rak != null) {
            if (GemFireXDUtils.TraceOuterJoin || GemFireXDUtils.TraceNCJIter) {
              SanityManager.DEBUG_PRINT(
                  GfxdConstants.TRACE_OUTERJOIN_MERGING,
                  "BackingStoreHashTable::add_row_to_hash_table putting rak: "
                      + rak + " against key: " + key + " for row: "
                      + Arrays.toString(row));
            }
            this.hash_table_for_RegionNameAndKey.put(key, rak);
          }
       // Gemstone changes END
            doSpaceAccounting( row, false);
        }
        else
        {
            if (!remove_duplicates)
            {
                List row_vec;

                // Gemstone changes BEGIN
                List rak_vec = null;
                // Gemstone changes END
                // inserted a duplicate
                if (duplicate_value instanceof List)
                {
                    doSpaceAccounting( row, false);
                    row_vec = (List) duplicate_value;
                 // Gemstone changes BEGIN
                    if (rak != null) {
                      rak_vec = (List) this.hash_table_for_RegionNameAndKey.get(key);
                    }
                 // Gemstone changes END
                }
                else
                {
                    // allocate list to hold duplicates
                    row_vec = new ArrayList(2);

                    // insert original row into vector
                    row_vec.add(duplicate_value);
                 // Gemstone changes BEGIN
                    if (rak != null) {
                      rak_vec = new ArrayList(2);
                      if (GemFireXDUtils.TraceOuterJoin || GemFireXDUtils.TraceNCJIter) {
                        SanityManager
                            .DEBUG_PRINT(
                                GfxdConstants.TRACE_OUTERJOIN_MERGING,
                                "BackingStoreHashTable::add_row_to_hash_table created list of size 2 and added rak: "
                                    + rak + " against key: " + key);
                      }
                      rak_vec.add(this.hash_table_for_RegionNameAndKey.get(key));
                    }
                 // Gemstone changes END
                    doSpaceAccounting( row, true);
                }

                // insert new row into list
                row_vec.add(row);
                // Gemstone changes BEGIN
                if (rak_vec != null) {
                  rak_vec.add(rak);
                }
             // Gemstone changes END

                // store list of rows back into hash table,
                // overwriting the duplicate key that was
                // inserted.
                hash_table.put(key, row_vec);
                // Gemstone changes BEGIN
                if (rak != null && rak_vec != null) {
                  this.hash_table_for_RegionNameAndKey.put(key, rak_vec);
                }
                // Gemstone changes END
            }
        }

        row = null;
    }

    private void doSpaceAccounting(DataValueDescriptor[] row,
                                    boolean firstDuplicate)
    {
        inmemory_rowcnt++;
        if( max_inmemory_rowcnt <= 0)
        {
            max_inmemory_size -= getEstimatedMemUsage(row);
            if( firstDuplicate)
                max_inmemory_size -= ARRAY_LIST_SIZE;
        }
    } // end of doSpaceAccounting

    /**
     * Determine whether a new row should be spilled to disk and, if so, do it.
     *
     * @param row
     *
     * @return true if the row was spilled to disk, false if not
     *
     * @exception  StandardException  Standard exception policy.
     */
    private boolean spillToDisk(DataValueDescriptor[] row) throws StandardException {

        // currently failing the query if CRITICAL_UP has been reached
        if (!this.thresholdListener.isCritical()) {
          return false;
        }
        else {
          throw StandardException
              .newException(SQLState.OVERFLOW_TO_DISK_UNSUPPORTED);
        }
        /*
        // Once we have started spilling all new rows will go to disk, even if we have freed up some
        // memory by moving duplicates to disk. This simplifies handling of duplicates and accounting.
        if( diskHashtable == null)
        {
            if( max_inmemory_rowcnt > 0)
            {
                if( inmemory_rowcnt < max_inmemory_rowcnt)
                    return false; // Do not spill
            }
            else if( max_inmemory_size > getEstimatedMemUsage(row))

                return false;
            // Want to start spilling
//Gemstone changes Begin
            //@yjing gracefully throw unsupported exception and comment out the following code.
            throw StandardException.newException(SQLState.OVERFLOW_TO_DISK_UNSUPPORTED);
/*
            diskHashtable =
                new DiskHashtable(
                       tc,
                       row,
                       (int[]) null, //TODO-COLLATION, set non default collation if necessary.
                       key_column_numbers,
                       remove_duplicates,
                       keepAfterCommit);
 * /
     //Gemstone changes End
        }
        Object key = KeyHasher.buildHashKey(row, key_column_numbers);
        Object duplicateValue = hash_table.get( key);
        if( duplicateValue != null)
        {
            if( remove_duplicates)
                return true; // a degenerate case of spilling
            // If we are keeping duplicates then move all the duplicates from memory to disk
            // This simplifies finding duplicates: they are either all in memory or all on disk.
            if (duplicateValue instanceof List)
            {
                List duplicateVec = (List) duplicateValue;
                for( int i = duplicateVec.size() - 1; i >= 0; i--)
                {
                    DataValueDescriptor[] dupRow = (DataValueDescriptor[]) duplicateVec.get(i);
                    diskHashtable.put( key, dupRow);
                }
            }
            else
                diskHashtable.put( key, (DataValueDescriptor[]) duplicateValue);
            hash_table.remove( key);
        }
        diskHashtable.put( key, row);
        return true;
         */
    } // end of spillToDisk

    /**
     * Take a row and return an estimate as to how much memory that
     * row will consume.
     *
     * @param row The row for which we want to know the memory usage.
     * @return A guess as to how much memory the current row will
     *  use.
     */
    private long getEstimatedMemUsage(DataValueDescriptor[] row)
    {
        long rowMem = 0;
        for( int i = 0; i < row.length; i++)
        {
            rowMem += row[i].estimateMemoryUsage();
            rowMem += ClassSize.refSize;
        }

        rowMem += ClassSize.refSize;
        return rowMem;
    }

    /**************************************************************************
     * Public Methods of This class:
     **************************************************************************
     */

    /**
     * Close the BackingStoreHashtable.
     *

     * Perform any necessary cleanup after finishing with the hashtable.  Will
     * deallocate/dereference objects as necessary.  If the table has gone
     * to disk this will drop any on disk files used to support the hash table.
     *

     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public void close()
		throws StandardException
    {
        hash_table = null;
        if( diskHashtable != null)
        {
            diskHashtable.close();
            diskHashtable = null;
        }
        return;
    }

    /**
     * Return an Enumeration that can be used to scan entire table.
     *

     * RESOLVE - is it worth it to support this routine when we have a
     *           disk overflow hash table?
     *
	 * @return The Enumeration.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public Enumeration elements()
        throws StandardException
    {
        if( diskHashtable == null)
            return Collections.enumeration(hash_table.values());
        return new BackingStoreHashtableEnumeration();
    }

    /*
     * For NCJ Use
     */
    public Iterator valuesIterator() throws StandardException {
      return new BackingStoreHashtableValues();
    }

    /**
     * get data associated with given key.
     *

     * There are 2 different types of objects returned from this routine.
     *

	 * In both cases, the key value is either the object stored in
     * row[key_column_numbers[0]], if key_column_numbers.length is 1,
     * otherwise it is a KeyHasher containing
	 * the objects stored in row[key_column_numbers[0, 1, ...]].
     * For every qualifying unique row value an entry is placed into the
     * hash table.
     *

     * For row values with duplicates, the value of the data is a list of
     * rows.
     *

     * The caller will have to call "instanceof" on the data value
     * object if duplicates are expected, to determine if the data value
     * of the hash table entry is a row or is a list of rows.
     *

     * The BackingStoreHashtable "owns" the objects returned from the get()
     * routine.  They remain valid until the next access to the
     * BackingStoreHashtable.  If the client needs to keep references to these
     * objects, it should clone copies of the objects.  A valid
     * BackingStoreHashtable can place all rows into a disk based conglomerate,
     * declare a row buffer and then reuse that row buffer for every get()
     * call.
     *
	 * @return The value to which the key is mapped in this hashtable;
     *         null if the key is not mapped to any value in this hashtable.
     *
     * @param key    The key to hash on.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public Object get(Object key)
		throws StandardException
    {
        Object obj = hash_table.get(key);
        if( diskHashtable == null || obj != null)
            return obj;
        return diskHashtable.get( key);
    }

    /**
     * Return runtime stats to caller by adding them to prop.
     *

     *
     * @param prop   The set of properties to append to.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public void getAllRuntimeStats(Properties   prop)
		throws StandardException
    {
        if (auxillary_runtimestats != null)
            com.pivotal.gemfirexd.internal.iapi.util.PropertyUtil.copyProperties(auxillary_runtimestats, prop);
    }

    /**
     * remove a row from the hash table.
     *

     * a remove of a duplicate removes the entire duplicate list.
     *
     * @param key          The key of the row to remove.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public Object remove(
    Object      key)
		throws StandardException
    {
        Object obj = hash_table.remove(key);
        if( obj != null || diskHashtable == null)
            return obj;
        return diskHashtable.remove(key);
    }

    /**
     * Set the auxillary runtime stats.
     *

     * getRuntimeStats() will return both the auxillary stats and any
     * BackingStoreHashtable() specific stats.  Note that each call to
     * setAuxillaryRuntimeStats() overwrites the Property set that was
     * set previously.
     *
     * @param prop   The set of properties to append from.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public void setAuxillaryRuntimeStats(Properties   prop)
		throws StandardException
    {
        auxillary_runtimestats = prop;
    }

    /**
     * Put a row into the hash table.
     *

     * The in memory hash table will need to keep a reference to the row
     * after the put call has returned.  If "needsToClone" is true then the
     * hash table will make a copy of the row and put that, else if
     * "needsToClone" is false then the hash table will keep a reference to
     * the row passed in and no copy will be made.
     *

     * If rouine returns false, then no reference is kept to the duplicate
     * row which was rejected (thus allowing caller to reuse the object).
     *
     * @param needsToClone does this routine have to make a copy of the row,
     *                     in order to keep a reference to it after return?
     * @param row          The row to insert into the table.
     *
	 * @return true if row was inserted into the hash table.  Returns
     *              false if the BackingStoreHashtable is eliminating
     *              duplicates, and the row being inserted is a duplicate,
	 *				or if we are skipping rows with 1 or more null key columns
	 *				and we find a null key column.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    // Gemstone changes BEGIN
    public boolean putRow(
    boolean     needsToClone,
    DataValueDescriptor[]    row, RegionAndKey rak)
		throws StandardException
    // Gemstone changes END
    {
		// Are any key columns null?
		if (skipNullKeyColumns)
		{
			int index = 0;
			for ( ; index < key_column_numbers.length; index++)
			{
				if (row[key_column_numbers[index]].isNull())
				{
					return false;
				}
			}
		}

        Object key = KeyHasher.buildHashKey(row, key_column_numbers);

        if ((remove_duplicates) && (get(key) != null))
        {
            return(false);
        }
        else
        {
       // Gemstone changes BEGIN
          if (GemFireXDUtils.TraceOuterJoin || GemFireXDUtils.TraceNCJIter) {
            SanityManager.DEBUG_PRINT(GfxdConstants.TRACE_OUTERJOIN_MERGING,
                "BackingStoreHashTable::putRow calling add_row_to_hash_table for row = "
                    + Arrays.toString(row) + ", needsToclone: " + needsToClone
                    + " and rak: " + rak);
          }
          // Gemstone changes END
            add_row_to_hash_table(row, needsToClone, rak);
            return(true);
        }
    }

    /**
     * Return number of unique rows in the hash table.
     *

     *
	 * @return The number of unique rows in the hash table.
     *
	 * @exception  StandardException  Standard exception policy.
     **/
    public int size()
		throws StandardException
    {
        if( diskHashtable == null)
            return(hash_table.size());
        return hash_table.size() + diskHashtable.size();
    }

    private class BackingStoreHashtableEnumeration implements Enumeration
    {
        private Iterator memoryIterator;
        private Enumeration diskEnumeration;

        BackingStoreHashtableEnumeration()
        {
            memoryIterator = hash_table.values().iterator();
            if( diskHashtable != null)
            {
                try
                {
                    diskEnumeration = diskHashtable.elements();
                }
                catch( StandardException se)
                {
                    diskEnumeration = null;
                }
            }
        }

        public boolean hasMoreElements()
        {
            if (memoryIterator != null) {
                if (memoryIterator.hasNext()) {
                    return true;
                }
                memoryIterator = null;
            }
            if( diskEnumeration == null)
                return false;
            return diskEnumeration.hasMoreElements();
        }

        public Object nextElement() throws NoSuchElementException
        {
            if (memoryIterator != null) {
                if (memoryIterator.hasNext()) {
                    return memoryIterator.next();
                }
                memoryIterator = null;
            }
            return diskEnumeration.nextElement();
        }

    } // end of class BackingStoreHashtableEnumeration

    /*
     * For NCJ Use
     */
    public class BackingStoreHashtableValues implements Iterator {
      private Iterator memoryIterator;

      BackingStoreHashtableValues() {
        memoryIterator = hash_table.values().iterator();
      }

      @Override
      public boolean hasNext() {
        if (memoryIterator != null) {
          if (memoryIterator.hasNext()) {
            return true;
          }
          memoryIterator = null;
        }

        return false;
      }

      @Override
      public Object next() {
        if (memoryIterator != null) {
          if (memoryIterator.hasNext()) {
            return memoryIterator.next();
          }
          memoryIterator = null;
        }
        return null;
      }

      @Override
      public void remove() {
        // TODO Auto-generated method stub

      }
    } // end of class BackingStoreHashtableValues

 // Gemstone changes BEGIN
  private final THashMap hash_table_for_RegionNameAndKey = new THashMap();

  public Object getFromRegionAndKeyHash(Object key) throws StandardException {
    return this.hash_table_for_RegionNameAndKey.get(key);
  }

  protected void assertHashTableNotNull() {
    SanityManager.ASSERT(this.hash_table != null);
  }

  /*
   * Especially for NCJ usage, during batching
   *
   * Will return true if all entries from below have not been fetched yet
   */
  public boolean moreRowsExpected() {
    return false;
  }

  /*
   * Especially for NCJ usage, during batching
   *
   * @see flag fillUpHashTable
   */
  public boolean fillUpHashTable() throws StandardException {
    SanityManager.THROWASSERT("Should be called for derived class");
    return false;
  }

  /*
   * Empty rows from Hash Table
   */
  public void purgeHashTable() {
    assertHashTableNotNull();
    this.hash_table.clear();
  }
    // Gemstone changes END
}


text:
Our patients can bring one visitor to our hospitals and clinics. Other restrictions still apply.
There is no panel matching the key "MicroAlert"
Home > Care & Treatment > Physical Therapy & Occupational Therapy > Lymphedema Care
Physical Therapy & Occupational Therapy
Before your appointment
Lymphedema is the swelling of a body part, most often an arm or leg, which is caused by an accumulation of lymphatic fluid. It can also occur in the abdomen, face, and neck. Lymphedema cannot be cured, however it can be reduced and controlled with therapy and self-management.
Our lymphedema management program was established in 1998 and is the longest standing lymphedema program in our regional service area. Our occupational and physical therapists have been trained in one or more methods of lymphedema treatment, including specialized training in European and American methods.
Symptoms of lymphedema
Lymphedema begins as a soft, fluid-filled swelling anywhere on the body. The affected area may also become inflamed. Eventually the area thickens, becomes fibrotic, or hardened, and the skin breaks down.
The patient may experience increased pain in the area, heaviness or diminished range of motion in the affected limb and increased difficulty performing normal activities. If you notice persistent swelling, it is very important that you seek immediate medical advice as early diagnosis and treatment improve both the prognosis and the condition.
Who is a candidate for lymphedema treatment?
Those who have experienced swelling following lymph node removal, radiation, infection or trauma
People who have noticed an increase in swelling due to venous edema
Those who have congenital impairment of the lymphatic system
Types and causes of lymphedema
Primary lymphedema is caused by a deficient lymphatic system. Swelling can be present at birth or may not occur until later years.
Secondary lymphedema
Secondary lymphedema is caused by removal of, or damage to, lymph nodes or lymphatic structures. This may result in a permanent blockage of fluid from an area. Secondary lymphedema can develop as a result of surgery, radiation trauma, infection or venous insufficiency.
A specific treatment program is designed to fit the needs of each person.
Treatment may consist of:
Manual lymphatic treatment, a light massage to remove and reroute fluid
Compression bandaging
Skin care instruction
Patient education in self-management techniques
What if lymphedema is untreated?
If lymphedema is untreated, the risk of infection increases in the affected area due to the build-up of protein-rich fluid which acts as a breeding ground for bacteria. A person may also experience pain, heaviness or diminished use of the involved limb.
Find Lymphedema Care
Skip insurance and pay cash when you check in.
Gundersen St. Joseph's cardiac rehab certified by industry leader July 29, 2020
Occupational therapist joins Gundersen Tri-County July 24, 2020
Related Healthy Living
9 benefits of physical and occupational therapy February 5, 2020
Pain treatment options October 17, 2017
Getting back to normal activity after having a baby March 13, 2017
New back pain guidelines March 8, 2017
Contact Medical Records
Attend a Class or Event
Talk to a Nurse
We've taken steps at all our locations to keep you and our staff healthy and safe. Here's what to expect when you visit us.
Gundersen Health System • (608) 782-7300 • Contact Us
1900 South Ave. • La Crosse, WI 54601
Community Assessments, Plans & Contributions
Quartz Benefits
For Clinicians & Professionals
Get Our e-Newsletters
Forms & Notices
Copyright 2021 Gundersen Health System.
Privacy Policy | Terms of Use | ADA & ASL | Español | Hmong | Other Languages | Notice of Non-Discrimination


With Telltale closing down and the future of their take on Robert Kirkman's post-apocalyptic world uncertain, people will be looking to Overkill's The Walking Dead for their walker-slaying fix. The good news is that after a series of delays, the game is finally coming out on PC next week.
As most people know, Kirkman's universe is set in a post-apocalyptic world where everybody who dies or is bitten becomes a walker, unless they're heads are blown out or impaled. Overkill's entry takes place in Washington D.C. and features four original characters. Each one will feature unique skills and weapon choices. Although the game will only have a slight focus on narrative, Kirkman has said that what little the game offers will be canon.
After a series of delays, Overkill's The Walking Dead is finally set to launch on November 8th for PC, while Xbox One and PS4 players will have to wait till February 6th to get it. When asked about a Switch port, the devs only gave a not so reassuring "maybe".


Ms. Amy is from Jeffrey's Bay, South Africa and studied a bachelor of arts in human kinetics and ergonomics as well as drama at Rhodes University. She has also completed a PGCE to be a drama teacher and a TEFL course in the past year. She loves teaching and traveling.
Ms. Flora is from Cape Town, South Africa. She obtained a Bachelor of Administration degree in branding and business management. Ms. Flora completed her TEFL certificate through the TEFL Academy. She has a passion for working with children and has many years of au pairing experience. She has also worked as a camp counsellor at a summer camp in Connecticut, USA. In her free time, Ms. Flora enjoys cooking, socializing, taking photos and traveling. She is excited to create a positive classroom environment and to form meaningful relationships with her students.
Ms. Rhi was born in Rochford, United Kingdom and raised in Cambridge. She has a Bachelor's degree in Humanities majoring in History and Classics. Ms. Rhi has previous teaching experience in Spain. She completed her TEFL in 2015. Ms. Rhi enjoys meeting new people and learning about new cultures.
Ms. Emily is from Minnesota in the United States. She has degrees in English and Theater from St. Olaf College. After University Emily worked as a middle school teacher specifically working with at-risk youth. After receiving her TEFL certificate she moved to Hong Kong to begin working at Monkey Tree and couldn't be more excited! In her free time Emily enjoys theater, music, hiking, and traveling.
Mr Jordan is a native English speaker from York, England. He got his degree in Music from York St John University. Mr. Jordan has travelled to many countries but working for Monkey Tree is his first experience in Asia. He is looking forward to taking in all the amazing views, experiencing new cuisines and learning about Hong Kong.
Ms Natalie is from Belgium and has an English father. After obtaining her bachelor's degree in psychology she worked for a while in finance. Two years ago, she decided to change career paths and got her CELTA degree. She is now happily combining her love for travelling with the joys of teaching. She feels very lucky to be able to continue living her dream thanks to Monkey Tree and looks forward to meeting you all!


The 2018 European Championship 10m in the city of Györ, Hungary, will be on TV and in Internet. The Organizing Committee has already done all necessary arrangements for TV and Internet coverage of the Championship and all necessary commitments have been reached between the Hungarian Shooting Federation, the European Shooting Confederation and the European Broadcasting Union. Each Member Federation has a real opportunity to promote the shooting sport, the athletes and the sponsors.
The live TV broadcasting will include the Finals of six Olympic events: Air Rifle Men, Air Rifle Women, Air Pistol Mixed Team on February 23 and Air Pistol Men, Air Pistol Women, Air Rifle Mixed Team on February 24.
The live Internet streaming will cover all the Finals, including the Team competitions that will be held according to the new format, in Junior and Senior categories on February 20-25 as well as the Qualification for the 2018 Youth Olympic Games in Buenos-Aires on February 18.
The access to the EBU signal will be possible only with written permission from the European Shooting Confederation (ESC). In order to get such permission the TV companies which are interested to access the signal must apply to the ESC Secretariat (esc@escsport.eu) and pay the applicable rate for the broadcasting rights on the territory of their country.
In order to allow the audience in all the countries to follow the competitions of the best European shooters, the costs of the technical access to the EBU satellite of all the TV companies will be covered by the ESC.
The conditions of access to the Internet streaming will be formulated later. But all those who are interested in obtaining the rights for the Internet streaming can already contact the ESC Secretariat.
The complete preliminary competitions schedule can be found here.


text:
Fabrication of embedded microball lens in PMMA with high repetition rate femtosecond fiber laser
Chong Zheng, Anming Hu, Ruozhou Li, Denzel Bridges, and Tao Chen
Chong Zheng,1,2 Anming Hu,1,2,* Ruozhou Li,2,3 Denzel Bridges,2 and Tao Chen1,4
1Institute of Laser Engineering, Beijing University of Technology, Pingleyuan 100, Chaoyang District, Beijing 100124, China
2Department of Mechanical, Aerospace and Biomedical Engineering, University of Tennessee, Knoxville, Tennessee 37996, USA
3School of Electronic Science and Engineering, Southeast University, Key Laboratory of Micro-Inertial Instrument and Advanced Navigation Technology, Ministry of Education, Nanjing 210096, China
4chentao@bjut.edu.cn
*Corresponding author: ahu3@utk.edu
C Zheng
A Hu
R Li
D Bridges
T Chen
Chong Zheng, Anming Hu, Ruozhou Li, Denzel Bridges, and Tao Chen, "Fabrication of embedded microball lens in PMMA with high repetition rate femtosecond fiber laser," Opt. Express 23, 17584-17598 (2015)
Laser Microfabrication
Femtosecond fiber lasers
High power lasers
Integrated optics devices (130.3120)
Micro-optical devices (130.3990)
Laser damage (140.3330)
Laser materials processing (140.3390)
Ultrafast lasers (140.7090)
Original Manuscript: April 17, 2015
Revised Manuscript: June 20, 2015
Manuscript Accepted: June 21, 2015
Embedded microball lenses with superior optical properties function as convex microball lens (VMBL) and concave microball lens (CMBL) were fabricated inside a PMMA substrate with a high repetition rate femtosecond fiber laser. The VMBL was created by femtosecond laser-induced refractive index change, while the CMBL was fabricated due to the heat accumulation effect of the successive laser pulses irradiation at a high repetition rate. The processing window for both types of the lenses was studied and optimized, and the optical properties were also tested by imaging a remote object with an inverted microscope. In order to obtain the microball lenses with adjustable focal lengths and suppressed optical aberration, a shape control method was thus proposed and examined with experiments and ZEMAX® simulations. Applying the optimized fabrication conditions, two types of the embedded microball lenses arrays were fabricated and then tested with imaging experiments. This technology allows the direct fabrication of microlens inside transparent bulk polymer material which has great application potential in multi-function integrated microfluidic devices.
Welding of PMMA by a femtosecond fiber laser
Annalisa Volpe, Francesca Di Niso, Caterina Gaudiuso, Andrea De Rosa, Rebeca Martínez Vázquez, Antonio Ancona, Pietro Mario Lugarà, and Roberto Osellame
Microchannel fabrication in PMMA based on localized heating by nanojoule high repetition rate femtosecond pulses
Daniel Day and Min Gu
Opt. Express 13(16) 5939-5946 (2005)
Low-loss waveguides fabricated in BK7 glass by high repetition rate femtosecond fiber laser
Shane M. Eaton, Mi Li Ng, Jörn Bonse, Alexandre Mermillod-Blondin, Haibin Zhang, Arkadi Rosenfeld, and Peter R. Herman
Femtosecond laser induced selective etching in fused silica: optimization of the inscription conditions with a high-repetition-rate laser source
Jia Qi, Zhenhua Wang, Jian Xu, Zijie Lin, Xiaolong Li, Wei Chu, and Ya Cheng
Fabrication of a compound infrared microlens array with ultrashort focal length using femtosecond laser-assisted wet etching and dual-beam pulsed laser deposition
Chun Deng, Hyeongwon Kim, and Hyungson Ki
J. Kim, C. J. Nuzman, B. Kumar, D. F. Lieuwen, J. S. Kraus, A. Weiss, C. P. Lichtenwalner, A. R. Papazian, R. E. Frahm, N. R. Basavanhally, D. A. Ramsey, V. A. Aksyuk, F. Pardo, M. E. Simon, V. Lifton, H. B. Chan, M. Haueis, A. Gasparyan, H. R. Shea, S. Arney, C. A. Bolle, P. R. Kolodner, R. Ryf, D. T. Neilson, and J. V. Gates, "1100 x 1100 port MEMS-based optical crossconnect with 4-dB maximum loss," IEEE. Photon. Technol. Lett. 15(11), 1537–1539 (2003).
C. P. B. Siu, H. Zeng, and M. Chiao, "Magnetically actuated MEMS microlens scanner for in vivo medical imaging," Opt. Express 15(18), 11154–11166 (2007).
J. Arai, H. Kawai, and F. Okano, "Microlens arrays for integral imaging system," Appl. Opt. 45(36), 9066–9078 (2006).
Y. M. Song, Y. Xie, V. Malyarchuk, J. Xiao, I. Jung, K. J. Choi, Z. Liu, H. Park, C. Lu, R. H. Kim, R. Li, K. B. Crozier, Y. Huang, and J. A. Rogers, "Digital cameras with designs inspired by the arthropod eye," Nature 497(7447), 95–99 (2013).
J. C. Roulet, R. Völkel, H. P. Herzig, E. Verpoorte, N. F. de Rooij, and R. Dändliker, "Performance of an integrated microoptical system for fluorescence detection in microfluidic systems," Anal. Chem. 74(14), 3400–3407 (2002).
Y. Y. Sun, L. S. Ong, and X. C. Yuan, "Composite-microlens-array-enabled microfluidic sorting," Appl. Phys. Lett. 89(14), 141108 (2006).
J. C. Roulet, R. Volkel, H. P. Herzig, E. Verpoorte, N. F. de Rooij, and R. Dandliker, "Fabrication of multilayer systems combining microfluidic and microoptical elements for fluorescence detection," J. Microelectromech. Syst. 10(4), 482–491 (2001).
F. B. McCormick, F. A. P. Tooley, T. J. Cloonan, J. M. Sasian, H. S. Hinton, K. O. Mersereau, and A. Y. Feldblum, "Optical interconnections using microlens arrays," Opt. Quantum Electron. 24(4), S465–S477 (1992).
E. H. Park, M. J. Kim, and Y. S. Kwon, "Microlens for efficient coupling between LED and optical fiber," IEEE Photon. Technol. Lett. 11(4), 439–441 (1999).
J. W. Pan, C. M. Wang, H. C. Lan, W. S. Sun, and J. Y. Chang, "Homogenized LED-illumination using microlens arrays for a pocket-sized projector," Opt. Express 15(17), 10483–10491 (2007).
R. Winston, P. Schreiber, S. Kudaev, P. Dannberg, U. D. Zeitner, and R. J. Koshel, "Homogeneous LED-illumination using microlens arrays," Proc. SPIE 5942, 59420K (2005).
G. Schlingloff, H. J. Kiel, and A. Schober, "Microlenses as amplification for CCD-based detection devices for screening applications in biology, biochemistry, and chemistry," Appl. Opt. 37(10), 1930–1934 (1998).
N. Ma, P. C. Ashok, D. J. Stevenson, F. J. Gunn-Moore, and K. Dholakia, "Integrated optical transfection system using a microlens fiber combined with microfluidic gene delivery," Biomed. Opt. Express 1(2), 694–705 (2010).
P. Nussbaum, R. Völkel, H. P. Herzig, M. Eisner, and S. Haselbeck, "Design, fabrication and testing of microlens arrays for sensors and microsystems," Pure Appl. Opt. 6(6), 617–636 (1997).
Q. Dai, R. Rajasekharan, H. Butt, X. Qiu, G. Amaragtunga, and T. D. Wilkinson, "Ultrasmall microlens array based on vertically aligned carbon nanofibers," Small 8(16), 2501–2504 (2012).
Z. Wang, W. Guo, L. Li, B. Luk'yanchuk, A. Khan, Z. Liu, Z. Chen, and M. Hong, "Optical virtual imaging at 50 nm lateral resolution with a white-light nanoscope," Nat. Commun. 2, 218 (2011).
Y. Yan, L. Li, C. Feng, W. Guo, S. Lee, and M. Hong, "Microsphere-coupled scanning laser confocal nanoscope for sub-diffraction-limited imaging at 25 nm lateral resolution in the visible spectrum," ACS Nano 8(2), 1809–1816 (2014).
Y. J. Fan, Y. C. Wu, Y. Chen, Y. C. Kung, T. H. Wu, K. W. Huang, H. J. Sheen, and P. Y. Chiou, "Three dimensional microfluidics with embedded microball lenses for parallel and high throughput multicolor fluorescence detection," Biomicrofluidics 7(4), 044121 (2013).
M. A. Burns, B. N. Johnson, S. N. Brahmasandra, K. Handique, J. R. Webster, M. Krishnan, T. S. Sammarco, P. M. Man, D. Jones, D. Heldsinger, C. H. Mastrangelo, and D. T. Burke, "An integrated nanoliter DNA analysis device," Science 282(5388), 484–487 (1998).
Y. Cheng, K. Sugioka, K. Midorikawa, M. Masuda, K. Toyoda, M. Kawachi, and K. Shihoyama, "Three-dimensional micro-optical components embedded in photosensitive glass by a femtosecond laser," Opt. Lett. 28(13), 1144–1146 (2003).
Y. Cheng, H. L. Tsai, K. Sugioka, and K. Midorikawa, "Fabrication of 3D microoptical lenses in photosensitive glass using femtosecond laser micromachining," Appl. Phys., A Mater. Sci. Process. 85(1), 11–14 (2006).
A. A. Bettiol, C. N. B. Udalagama, E. J. Teo, J. A. van Kan, and F. Watt, "Embedded photonic structures fabricated in photosensitive glass using proton beam writing," Nucl. Instrum. Methods Phys. Res. Sect. B 260, 357–361 (2007).
J. M. Fernández-Pradas, D. Serrano, P. Serra, and J. L. Morenza, "Laser fabricated microchannels inside photostructurable glass-ceramic," Appl. Surf. Sci. 255(10), 5499–5502 (2009).
Y. Kondo, J. Qiu, T. Mitsuyu, K. Hirao, and T. Yoko, "Three-dimensional microdrilling of glass by multiphoton process and chemical etching," Jpn. J. Appl. Phys. 38(Part 2, No. 10A), L1146–L1148 (1999).
D. J. Hwang, T. Y. Choi, and C. P. Grigoropoulos, "Liquid-assisted femtosecond laser drilling of straight and three-dimensional microchannels in glass," Appl. Phys., A Mater. Sci. Process. 79(3), 605–612 (2004).
K. C. Vishnubhatla, N. Bellini, R. Ramponi, G. Cerullo, and R. Osellame, "Shape control of microchannels fabricated in fused silica by femtosecond laser irradiation and chemical etching," Opt. Express 17(10), 8685–8695 (2009).
Y. Li and S. Qu, "Water-assisted femtosecond laser ablation for fabricating three-dimensional microfluidic chips," Curr. Appl. Phys. 13(7), 1292–1295 (2013).
S. Juodkazis, S. Matsuo, H. Misawa, and K. Yamasaki, "Three-dimensional micro-channels in polymers: one-step fabrication," Appl. Phys., A Mater. Sci. Process. 77(3-4), 371–373 (2003).
D. F. Farson, H. W. Choi, C. M. Lu, and L. J. Lee, "Femtosecond laser bulk micromachining of microfluid channels in poly(methylmethacrylate)," J. Laser Appl. 18(3), 210–215 (2006).
Y. Ishii, S. Koike, Y. Arai, and Y. Ando, "Ink-jet fabrication of polymer microlens for optical-I/O chip packaging," Jpn. J. Appl. Phys. 39(1), 1490–1493 (2000).
M. He, X. C. Yuan, N. Q. Ngo, J. Bu, and V. Kudryashov, "Simple reflow technique for fabrication of a microlens array in solgel glass," Opt. Lett. 28(9), 731–733 (2003).
A. Schilling, R. Merz, C. Ossmann, and H. P. Herzig, "Surface profiles of reflow microlenses under the influence of surface tension and gravity," Opt. Eng. 39(8), 2171–2176 (2000).
N. S. Ong, Y. H. Koh, and Y. Q. Fu, "Microlens array produced using hot embossing process," Microelectron. Eng. 60(3-4), 365–379 (2002).
Z. D. Popovic, R. A. Sprague, and G. A. N. Connell, "Technique for monolithic fabrication of microlens arrays," Appl. Opt. 27(7), 1281–1284 (1988).
M. Malinauskas, A. Žukauskas, V. Purlys, K. Belazaras, A. Momot, D. Paipulas, R. Gadonas, A. Piskarskas, H. Gilbergs, A. Gaidukevičiūtė, I. Sakellari, M. Farsari, and S. Juodkazis, "Femtosecond laser polymerization of hybrid/integrated micro-optical elements and their characterization," J. Opt. 12(12), 124010 (2010).
D. Wu, J.-N. Wang, L.-G. Niu, X. L. Zhang, S. Z. Wu, Q.-D. Chen, L. P. Lee, and H. B. Sun, "Bioinspired fabrication of high-quality 3D artificial compound eyes by voxel-modulation femtosecond laser writing for distortion-free wide-field-of-view imaging," Adv. Opt. Mater. 2(8), 751–758 (2014).
F. Chen, H. Liu, Q. Yang, X. Wang, C. Hou, H. Bian, W. Liang, J. Si, and X. Hou, "Maskless fabrication of concave microlens arrays on silica glasses by a femtosecond-laser-enhanced local wet etching method," Opt. Express 18(19), 20334–20343 (2010).
Y. Hu, Q. Yang, F. Chen, H. Bian, Z. Deng, G. Du, J. Si, F. Yun, and X. Hou, "Cost-efficient and flexible fabrication of rectangular-shaped microlens arrays with controllable aspect ratio and spherical morphology," Appl. Surf. Sci. 292, 285–290 (2014).
C. H. Lin, L. Jiang, Y. H. Chai, H. Xiao, S. J. Chen, and H. L. Tsai, "Fabrication of microlens arrays in photosensitive glass by femtosecond laser direct writing," Appl. Phys., A Mater. Sci. Process. 97(4), 751–757 (2009).
D. Wu, J. Xu, L.-G. Niu, S.-Z. Wu, K. Midorikawa, and K. Sugioka, "In-channel integration of designable microoptical devices using flat scaffold-supported femtosecond-laser microfabrication for coupling-free optofluidic cell counting," Light Sci. Appl. 4(1), e228 (2015).
C. Zheng, A. Hu, K. D. Kihm, Q. Ma, R. Li, T. Chen, and W. W. Duley, "Femtosecond laser fabrication of cavity microball lens (CMBL) inside a PMMA substrate for super-wide angle imaging," Small (2015), http://www.ncbi.nlm.nih.gov/pubmed/25740653 .
R. Buividas, S. Rekštytė, M. Malinauskas, and S. Juodkazis, "Nano-groove and 3D fabrication by controlled avalanche using femtosecond laser pulses," Opt. Mater. Express 3(10), 1674–1686 (2013).
S. Eaton, H. Zhang, P. Herman, F. Yoshino, L. Shah, J. Bovatsek, and A. Arai, "Heat accumulation effects in femtosecond laser-written waveguides with variable repetition rate," Opt. Express 13(12), 4708–4716 (2005).
Y. Bellouard and M. O. Hongler, "Femtosecond-laser generation of self-organized bubble patterns in fused silica," Opt. Express 19(7), 6807–6821 (2011).
A. Baum, P. J. Scully, W. Perrie, D. Liu, and V. Lucarini, "Mechanisms of femtosecond laser-induced refractive index modification of poly (methyl methacrylate)," J. Opt. Soc. Am. B 27(1), 107–111 (2010).
M. Ferriol, A. Gentilhomme, M. Cochez, N. Oget, and J. Mieloszynski, "Thermal degradation of poly (methyl methacrylate)(PMMA): modelling of DTG and TG curves," Polym. Degrad. Stabil. 79(2), 271–281 (2003).
A. Hu, M. Rybachuk, Q. B. Lu, and W. W. Duley, "Direct synthesis of sp-bonded carbon chains on graphite surface by femtosecond laser irradiation," Appl. Phys. Lett. 91(13), 131906 (2007).
H. Zappe, Fundamentals of Micro-Optics (Cambridge University, 2010).
Aksyuk, V. A.
Amaragtunga, G.
Ando, Y.
Arai, A.
Arai, J.
Arai, Y.
Arney, S.
Ashok, P. C.
Basavanhally, N. R.
Baum, A.
Belazaras, K.
Bellini, N.
Bellouard, Y.
Bettiol, A. A.
Bian, H.
Bolle, C. A.
Bovatsek, J.
Brahmasandra, S. N.
Bu, J.
Buividas, R.
Burke, D. T.
Burns, M. A.
Butt, H.
Cerullo, G.
Chai, Y. H.
Chan, H. B.
Chang, J. Y.
Chen, F.
Chen, Q.-D.
Chen, S. J.
Chen, T.
Chen, Y.
Chen, Z.
Chiao, M.
Chiou, P. Y.
Choi, H. W.
Choi, K. J.
Choi, T. Y.
Cloonan, T. J.
Cochez, M.
Connell, G. A. N.
Crozier, K. B.
Dai, Q.
Dandliker, R.
Dändliker, R.
Dannberg, P.
de Rooij, N. F.
Deng, Z.
Dholakia, K.
Du, G.
Duley, W. W.
Eaton, S.
Eisner, M.
Fan, Y. J.
Farsari, M.
Farson, D. F.
Feldblum, A. Y.
Feng, C.
Fernández-Pradas, J. M.
Ferriol, M.
Frahm, R. E.
Fu, Y. Q.
Gadonas, R.
Gaidukeviciute, A.
Gasparyan, A.
Gates, J. V.
Gentilhomme, A.
Gilbergs, H.
Grigoropoulos, C. P.
Gunn-Moore, F. J.
Guo, W.
Handique, K.
Haselbeck, S.
Haueis, M.
Heldsinger, D.
Herman, P.
Herzig, H. P.
Hinton, H. S.
Hirao, K.
Hong, M.
Hongler, M. O.
Hou, C.
Hou, X.
Hu, A.
Hu, Y.
Huang, K. W.
Huang, Y.
Hwang, D. J.
Ishii, Y.
Jiang, L.
Johnson, B. N.
Jones, D.
Jung, I.
Juodkazis, S.
Kawachi, M.
Kawai, H.
Khan, A.
Kiel, H. J.
Kihm, K. D.
Kim, J.
Kim, M. J.
Kim, R. H.
Koh, Y. H.
Koike, S.
Kolodner, P. R.
Kondo, Y.
Koshel, R. J.
Kraus, J. S.
Krishnan, M.
Kudaev, S.
Kudryashov, V.
Kumar, B.
Kung, Y. C.
Kwon, Y. S.
Lan, H. C.
Lee, L. J.
Lee, L. P.
Lee, S.
Liang, W.
Lichtenwalner, C. P.
Lieuwen, D. F.
Lifton, V.
Lin, C. H.
Liu, D.
Liu, H.
Liu, Z.
Lu, C.
Lu, C. M.
Lu, Q. B.
Lucarini, V.
Luk'yanchuk, B.
Ma, N.
Ma, Q.
Malinauskas, M.
Malyarchuk, V.
Man, P. M.
Mastrangelo, C. H.
Masuda, M.
Matsuo, S.
McCormick, F. B.
Mersereau, K. O.
Merz, R.
Midorikawa, K.
Mieloszynski, J.
Misawa, H.
Mitsuyu, T.
Momot, A.
Morenza, J. L.
Neilson, D. T.
Ngo, N. Q.
Niu, L.-G.
Nussbaum, P.
Nuzman, C. J.
Oget, N.
Okano, F.
Ong, L. S.
Ong, N. S.
Osellame, R.
Ossmann, C.
Paipulas, D.
Pan, J. W.
Papazian, A. R.
Pardo, F.
Park, E. H.
Park, H.
Perrie, W.
Piskarskas, A.
Popovic, Z. D.
Purlys, V.
Qiu, J.
Qiu, X.
Qu, S.
Rajasekharan, R.
Ramponi, R.
Ramsey, D. A.
Rekštyte, S.
Rogers, J. A.
Roulet, J. C.
Rybachuk, M.
Ryf, R.
Sakellari, I.
Sammarco, T. S.
Sasian, J. M.
Schilling, A.
Schlingloff, G.
Schober, A.
Schreiber, P.
Scully, P. J.
Serra, P.
Serrano, D.
Shah, L.
Shea, H. R.
Sheen, H. J.
Shihoyama, K.
Simon, M. E.
Siu, C. P. B.
Song, Y. M.
Sprague, R. A.
Stevenson, D. J.
Sugioka, K.
Sun, H. B.
Sun, W. S.
Sun, Y. Y.
Teo, E. J.
Tooley, F. A. P.
Toyoda, K.
Tsai, H. L.
Udalagama, C. N. B.
van Kan, J. A.
Verpoorte, E.
Vishnubhatla, K. C.
Volkel, R.
Völkel, R.
Wang, C. M.
Wang, J.-N.
Wang, X.
Watt, F.
Webster, J. R.
Weiss, A.
Wilkinson, T. D.
Winston, R.
Wu, D.
Wu, S. Z.
Wu, S.-Z.
Wu, T. H.
Wu, Y. C.
Xiao, H.
Xiao, J.
Xie, Y.
Yamasaki, K.
Yan, Y.
Yang, Q.
Yoko, T.
Yoshino, F.
Yuan, X. C.
Yun, F.
Zeitner, U. D.
Zeng, H.
Zhang, H.
Zhang, X. L.
Zheng, C.
Žukauskas, A.
ACS Nano (1)
Adv. Opt. Mater. (1)
Anal. Chem. (1)
Appl. Opt. (3)
Appl. Phys., A Mater. Sci. Process. (4)
Appl. Surf. Sci. (2)
Biomed. Opt. Express (1)
Biomicrofluidics (1)
Curr. Appl. Phys. (1)
IEEE Photon. Technol. Lett. (1)
IEEE. Photon. Technol. Lett. (1)
J. Laser Appl. (1)
J. Microelectromech. Syst. (1)
J. Opt. (1)
Jpn. J. Appl. Phys. (2)
Microelectron. Eng. (1)
Nat. Commun. (1)
Nucl. Instrum. Methods Phys. Res. Sect. B (1)
Opt. Eng. (1)
Opt. Mater. Express (1)
Opt. Quantum Electron. (1)
Polym. Degrad. Stabil. (1)
Proc. SPIE (1)
Pure Appl. Opt. (1)
Fig. 1 Experimental configurations and the schematic for the fabrication of different types of embedded microball lens (VMBL and CMBL): (i) VMBL is fabricated when laser power intensity is adjusted to in a relatively low level at which a refractive index modified region generated after laser irradiation. (b) CMBL is fabricated at a relatively higher power level at which an embedded micro-cavity formed after manufacturing.
Fig. 2 The structural development of microlenses with different average power. (a) A melted region is generated accompanied with cracks at the center of the ablated region (30 mW, 1.8 × 1013W/cm2). (b) and (c) shows nonuniform affected zones are created with sharp edges (50 mW, 3.0 × 1013W/cm2) and will be smoother if further increase the average power (70 mW, 4.2 × 1013W/cm2). (d) A uniform and symmetric VMBL is generated (90 mW, 5.4 × 1013W/cm2). (e) A bubble is generated and formed a cavity at the edge of the affected zone (130 mW, 7.8 × 1013W/cm2). (f) and (g) shows bubble is generated nonuniformly with insufficient energy (150 mW ~170 mW, 9.1 × 1013W/cm2 ~1.0 × 1014W/cm2). (h) Symmetric CMBL is generated when average power reaches 400 mW (2.4 × 1014 W/cm2).
Fig. 3 Development of the CMBL sizes when increasing the average laser power. The inset figures shows with processing window for a symmetric CMBL is from 400 mW to 1.5 W (2.4 × 1014 W/cm2 ~9.1 × 1014 W/cm2), otherwise an aspherical cavity or over-ablated CMBL will generated if the laser average power is insufficient or excessive.
Fig. 4 The dimension developments of VMBL and its image with the cooling time. (a) shows that the diameter of VMBL slightly increased after cooling for 80 min, meanwhile the image taken by the cooled VMBL shows distinguished increase. (b) illustrates the diameter development of VMBL and its image with the cooling time.
Fig. 5 (a) A micro-telescope is constructed with microball lens and microscopic objective, enables telescopic imaging of the brightened mask as illustrated. Images captured by a micro-telescopic system with the front lens of (b) VMBL or (c) CMBL.
Fig. 6 Shape control of CMBL horizontally (along X-axis or Y-axis) and vertically (along Z-axis) by scanning with the laser for 1~7 cycles in 5s. (a) Scan with a 1.2 W laser power at a repetition rate 120 kHz in a scanning distance for 80 μm. (b) Scan with a 1.4 W laser power at a repetition rate 120 kHz in a scanning distance for 45 μm. (c) An X-axis shape controlled sample. (d) A Z-axis shape controlled sample.
Fig. 7 Z-axis shape control of CMBL scanning at a speed of 72 μm/s and a distance 45 μm for 4 cycles while irradiation. (a) The image of a letter "F" taken by a CMBL with a spherical cavity fabricated without Z-axis shape control. (b) The side view of the CMBL with spherical cavity. (c) The image of a letter "F" taken by a CMBL with an elliptical cavity after Z-axis shape control. (d) The side view of the CMBL with elliptical cavity.
Fig. 8 Optical properties of CMBL with different shapes. (a) ~(c) Spherical cavity CMBL and elliptical cavity CMBLs; (d) ~(f) The geometric image of a letter "F"; (g) ~(i) The distortion curves when imaging with different CMBLs. The colorful curves represents the distortion curve of the incident light with different wavelengths, in which the blue light (484 nm), the green light (588 nm), and red light (656 nm) are represented by the curves with the same color.
Fig. 9 Snap shot of the stress wavefront propagation process.
Fig. 10 (a) The boundary deformation caused by the stress wavefront. The defects are partially cured and the boundary of the fabricated CMBL is smoother. (b) The diameters of the cavity regions (CR) and the affected zones (AZ) develop with different annealing temperature ranging from 70 °C to 90 °C. (c) The CMBL sample annealed in 100 °C.
Fig. 11 (a) Imaging of the word "UT" with 5 × 4 CMBL array. (b) Imaging of a lightened ring mask with a 4 × 3 VMBLs array. (c) A Letter "UT" is imaged with this VMBL array.


text:
Slots are games that players can play for real money. They are played by spinning reels, and the player is rewarded with credits based on the symbols that land on the pay line. A win may occur if a combination of symbols lands, or the player may be lucky enough to win a large jackpot.
A slot machine is a mechanical device that is activated by a lever or a button. The machine accepts cash or paper tickets with barcodes. It also has a credit meter that displays the number of credits that are on the machine. The game is usually played in a group of slot machines called a carousel.
Some slots have a bonus mode, which is a special feature that awards credits for certain symbols that lands during the feature. The bonus mode is usually aligned with the theme of the slot. The bonus mode is usually accompanied by an energizing piece of music that can boost the odds of winning.
A bonus mode can include special winning scenes that appear on the LCD display. Some slots allow a player to play several bonus rounds in a row. Some of the highest payouts are achieved by lucky players who play multiple bonus rounds.
Some slots feature a high volatility, which means the player's chances of winning are higher. In most cases, the probability of winning a big jackpot is zero, so most players will not win anything. However, there are some slots that feature larger jackpots, and some are designed to provide smaller wins more often. In addition, some video slots offer features that enhance the player's chances of winning with increased wagers.
One of the most common features on slot machines is the Hold&Spin feature. This feature allows a player to spin the machine until a symbol lands, and then keep the symbol on the screen until a new symbol lands. During the Hold&Spin feature, the player is awarded credits for landing special symbols.
Pragmatic Play slots have a unique three-dimensional feel. They have a few pay lines, and the symbols are fruit and other classic arcade characters. Some of the most popular hits are the Hold&Spin feature and the Reel Kingdom.
Pragmatic slots have a low risk factor, meaning that players can enjoy the game without worrying about losing a lot of money. Pragmatic Play primarily relies on promotion campaigns and traditional affiliates to generate revenue. They also have a variety of high RTP slot games, and they are known for their high-quality graphics and striking sound effects. The studio does not focus on producing games that feature unique stories, but instead focuses on producing slots that are appealing to both gamblers and non-gamblers.
The company also offers a freespins bonus, where all players get a free bonus for every spin they make. This bonus is only available to new members and existing members. The company offers a 100% welcome bonus for all new players.


text:
TENANT NEWS: SSK RECRUITMENT PLANS FOR EXPANSION
Nov 1, 2018 | TENANT NEWS
An East Durham recruitment company is looking to expand across the region.
SSK Recruitment, a general recruiter with a particular focus on construction, industrial, engineering and education, is aiming to open two further locations in Bishop Auckland by the end of November, as well as Stockton by Q1 2019.
The company was set up in March 2018 by managing director, Adam Smith with the support of local businessmen Bradley Saunders and Paul Kelly – who are also directors within the business.
Adam said: "We [began] trading in March this year and we were lucky enough to have a few doors opened for us by my business partners who have an abundance of contacts here in the North East.
"We set up on the back of two national construction contracts and the business has grown significantly off the back of those contracts.
"We achieved our gross status within the construction sector and have been mulling over plans to expand our operations across the region."
Source – Bdaily


I love it -- especially the graffiti. It adds nice detail, color. Plus I love graffiti anyway.
The Wall was beautiful, if seen from the West. It greatly saddened me that they broke it into tiny pieces. It would have been so meaningful as a giant memorial. But they wanted the real estate to build skyscrapers, at least in the center of Berlin, on the site of the old Potsdamer Platz.
Agreed. The new Sony center or whatever is at the Potsdamer Platz is too much. Even more absurd is that the contractors and city planners publicized the construction as creating "the new center of Berlin" (i.e. one more in the middle than the financial center of west Berlin). Really its just a big movie theater. The wall is beautiful though. Have you been to any of the bars or outdoor "beach" spaces between the relocated wall and the Spree? its a neat area. Looks like southern Arizona is about to get a wall of its own.
I haven't been back since they did all that. But I've seen coverage of it and also that New Berlin show at the Phoenix Art Museum.
I doubt whether our wall will be decorated, though I'm sure Don Delillo could imagine what that redemptive act would be like, given the passage in Underworld about the airplane graveyard.