text:
Browse the Collections Portfolios Exhibitions Artists Geography
Milestones in American Art
Trial Scene - David Gilmour Blythe The Artist's Studio in an Afternoon Fog - Winslow Homer Judge and Mrs. Arthur Yates - M. M. Manchester Louise Weiland Shakespeare (Mrs. William Shakespeare) - John Singer Sargent Russell Sturgis (1750 - 1826) - Gilbert Stuart Elizabeth Perkins Sturgis (1756 - 1843) - Gilbert Stuart
Blythe, David Gilmour 1
Homer, Winslow 1
Manchester, M. M. 1
Stuart, Gilbert 2
The Artist's Studio in an Afternoon Fog
24 x 30 1/4 in. (61 x 76.8 cm)
United States (Boston, MA, 1836 - 1910, Prout's Neck, ME)
Medium and Support: Oil on canvas
Credit Line: R. T. Miller Fund
Location: Currently on view
Link to this object
In the course of his long and distinguished career, Winslow Homer shifted his focus from robust descriptions of American life to studies of interaction between man and the powerful forces of nature, particularly the ocean. This evocative painting of his studio at his family's compound on the coast of Maine in Prout's Neck, near Portland, is considered one of Homer's most masterful works.
[Gallery label text, 2007]
A foggy day on the coastal peninsula of Prout's Neck, Maine, inspired Winslow Homer to paint one of his most elegant and contemplative works. His studio and family home stand silhouetted between the darker cliffs in the foreground and the paler sky. The painting's composition balances strong diagonal and horizontal elements in the lower half with a monolithic sky punctuated by a circle of sun.
Homer was known for his many paintings of rural America, as well as his illustrations of the Civil War. In 1883, Homer left New York City, where he had been living, and settled permanently in Prout's Neck. During his years there, he produced some of the most thrilling marine paintings in the history of American art.
Artist's signature, lower right: Winslow Homer 1894
John Calvin Stevens, Portland, ME in 1901 from the artist in payment for work; Stevens' estate, Portland, ME; purchased by the Gallery in 1941
weather & water
Audio & Video Resources
Explore Audio and Video Media
Panama-Pacific International Exhibition The Fine Arts Gallery of San Diego 1915
Century Loan Exhibition 7/17/1936 - 8/2/1936
Milestones in American Art Memorial Art Gallery 11/14/1941 - 12/7/1941
Winslow Homer: A Retrospective Exhibition National Gallery of Art 11/23/1958 - 5/3/1959
Summer Exhibit of Permanent Collection 6/1/1959 - 8/31/1959
Masters of Landscape: East and West Munson-Williams-Proctor Institute 9/15/1963 - 12/1/1963
Homer and the Sea: A Loan Exhibition of the Marine Paintings of Winslow Homer 9/27/1964 - 11/29/1964
American Paintings from Collection of the Memorial Art Gallery Memorial Art Gallery 1/13/1967 - 5/14/1967
Treasures from Rochester Memorial Art Gallery 4/14/1977 - 5/28/1977
American Light: The Luminist Movement 2/10/1980 - 6/15/1980
Through the Looking Glass 12/6/1980 - 1/25/1981
Golden Day, Silver Night: Perceptions of Nature in American Art 1850-1910 Herbert F. Johnson Museum of Art 2/3/1982 - 3/20/1983
Winslow Homer and the New England Coast 11/9/1984 - 1/9/1985
In Nature's Ways: American Landscape Painters of the Late 19th Cent. Norton Gallery 2/21/1987 - 4/12/1987
Winslow Homer The National Gallery of Art (Washington) 10/15/1995 - 9/22/1996
Winslow Homer: Facing Nature 3/3/2001 - 4/29/2001
Painting Summer in New England 4/18/2006 - 9/4/2006
Weatherbeaten: The Late Paintings of Winslow Homer 9/20/2012 - 12/30/2012
Jewel City: Art from the Panama-Pacific International Exposition 10/17/2015 - 1/10/2016
Winslow Homer and the Camera: Photography and the Art of Painting Bowdoin College Museum of Art 6/22/2018 - 2/17/2019
This object has the following bibliographic references:
Article Author: Junker, Patricia. Article Scope: Entry and reproduction. Susan Dodge Peters, ed. Memorial Art Gallery: An Introduction to the Collection. New York, New York: Memorial Art Gallery in association with Hudson Hills Press, 1988. Page Number: 190-191
Article Title: An Important Winslow Homer. Article Scope: Article. Memorial Art Gallery. Gallery Notes. Rochester, New York: Memorial Art Gallery, 1935-1995. Volume Number: 8, Issue Number: 2. Issue Date: November 1942.
Article Scope: Entry. Carl Little. Winslow Homer and the Sea. San Francisco, CA: Pomegranite Artbooks, 1995.
Article Scope: Reproduction only. Rochester Memorial Art Gallery of the University of Rochester Handbook. Rochester, NY: University of Rochester Press, 1961.
Article Scope: Entry and reproduction. Denys Sutton. Treasures from Rochester: Exhibited at Wildenstein Galleries, New York, April 14-May 28, 1977: Summary Catalogue. Rochester, New York: Memorial Art Gallery, 1977.
Democrat and Chronicle. Rochester, NY: Rochester Print Co.
Art Digest. New York, New York: Art Digest, Inc.
Article Author: Tatham, David. Article Title: Paddling at Dusk: Winslow Homer and Ernest Yalden. Article Scope: Article and reproduction. Porticus. Rochester, NY: Memorial Art Gallery Volume Number: 9 Issue Date: 1986. Page Number: 16-19, Figure Number: 2, p. 19
The Magazine Antiques. New York, NY: Straight Enterprises Inc.
Apollo. London, England: Apollo
Article Author: Gonnen, Noam. Article Title: Performing Openness: Open-air Painting and Conceptions of Openness in the Late Nineteenth-Century United States. Article Scope: Article. The Rutgers Art Review. New Brunswick, NJ: Students of the Graduate Program in Art History at Rutgers University Volume Number: 38 Issue Date: 2022. Page Number: 38, Figure Number: 10
Article Scope: Mention and reproduction. Elizabeth Brayer. Magnum Opus: The Story of the Memorial Art Gallery, 1913-1988. Rochester, NY: Memorial Art Gallery, 1988.
Grant Holcomb, III, ed. Voices in the Gallery: Writers on Art. Rochester, NY: University of Rochester Press, 2001.
American Art Annual. Washington, D.C.: The American Federation of the Arts
Irondequoit Press. Irondequoit, NY: Irondequoit Press
James Thomas Flexner. The World of Winslow Homer 1836-1910. New York, NY: Time-Life Books, 1966.
Winslow Homer at Prout's Neck. Brunswick, ME: Bowdoin College Museum of Art, 1966.
Bruce Robertson. Reckoning with Winslow Homer: His Late Paintings and Their Influence. Cleveland, OH: Cleveland Museum of Art, 1990.
Article Scope: Entry and reproduction. Lloyd Goodrich. Winslow Homer. New York, NY: Whitney Museum of American Art, 1976.
John Wilmerding. Winslow Homer. New York, NY: Praeger Publishers, 1972.
Art News.
John Wilmerding. American Light: The Luminist Movement, 1850-1875. Washington, D.C.: National Gallery of Art, 1980.
Article Scope: Entry and reproduction. Joseph S. Czestochowski. The American Landscape Tradition: A Study and Gallery of Paintings. New York, NY: E. P. Dutton & Co., Inc., 1982.
Elizabeth Johns. Winslow Homer: The Nature of Observation. Berkeley, CA: University of California Press, 2002.
Article Title: Globetrotters. Article Scope: Article and reproduction. MAGazine. Rochester, NY: Memorial Art Gallery Issue Date: November-December 1995. Page Number: 13
Memorial Art Gallery. ARTiculate. Rochester, NY: Memorial Art Gallery, 2000--.
Robert Demarest. Traveling with Winslow Homer: America's Premier Artist/Angler. New York, NY: Apple Trees Productions LLC, 2003.
Nicolai Cikovsky, Jr. and Franklin Kelly. Winslow Homer. Washington, D.C.: National Gallery of Art, 1995.
Art Gallery Magazine. Ivoryton, CT: Wm. C. Bendig
Priscilla Paton. Abandoned New England: Landscape in the works of Homer, Frost, Hopper, Wyeth and Bishop. Lebanon, N.H.: University Press of New England, 2003.
Dr. Denise Von Glahn. The Sounds of Place: Music and the Amerian Cultural Landscape. Boston, MA: Northeastern University Press, 2003.
Artists' Homes and Studios: A Special Kind of Archive. Washington, DC: Smithsonian American Art Museum, 2005.
Article Scope: Entry and reproduction. Winslow Homer: A Retrospective Exhibition. Washington, DC: National Gallery of Art, 1958.
Lloyd Goodrich. Winslow Homer. New York, NY: George Braziller, 1959.
Article Scope: Catalogue Raisonné Entry. Lloyd Goodrich. Record of Works by Winslow Homer. New York, NY: Spanierman Gallery, 2005-. Volume Number: V
Article Scope: Entry and reproduction. Trevor Fairbrother. Painting Summer in New England. Salem, MA: Peabody Essex Museum, 2006.
Dr. Gail Davidson. Frederick Church, Winslow Homer, and Thomas Moran: Tourism and the American Landscape. New York, NY: Bulfinch Press, 2006.
Article Scope: Mention and reproduction. Randall C. Griffin. Winslow Homer: An American Vision. London, England: Phaidon Press, Ltd., 2006.
Article Author: Tatham, David. Article Title: Winslow Homer: The Artist's Studio in an Afternoon Fog. Article Scope: Chapter and reproduction. Marjorie B. Searl, ed. Seeing America: painting and sculpture from the collection of the Memorial Art Gallery of the University of Rochester. Rochester, NY: Memorial Art Gallery, 2006. Page Number: 115-117
Article Scope: Mention and reproduction. Martha Tedeschi and Kristi Dahm. Watercolors by Winslow Homer: The Color of Light. New Haven, CT: Yale University Press, 2008.
Article Author: Corn, Wanda M.. Article Title: Artists' Homes and Studios: A Special Kind of Archive. Article Scope: Article and reproduction. American Art. Chicago, IL: University of Chicago Press, 1991-. Volume Number: 19, Issue Number: 1. Issue Date: Spring 2005. Page Number: 2-11
Winslow Homer: Society and Solitude. Princeton, NJ: Films for the Humanities & Sciences, 2007.
John Wilmerding. Compass and Clock: Defining Moments in American Culture 1800 1850 1900. New York NY: Harry N. Abrams, Inc., 1999.
Article Author: Junker, Patricia. Article Title: Expressions of Art and Life in The Artist's Studio in an Afternoon Fog. Winslow Homer in the 1890s: Prout's Neck observed. New York, NY: Hudson Hills Press, 1990. Page Number: 34-65, Figure Number: 2, p. 35
Article Author: Dittman, Emily K.. Article Title: Appendix of Winslow Homer Works in New York State. Article Scope: Mention. David Tatham. Winslow Homer's Empire State: Houghton Farm and Beyond. Syracuse, NY: Syracuse University Press, 2009. Page Number: 83
Article Author: Beem, Edgar Allen. Article Title: Winslow Homer's Odyssey. Article Scope: Article and reproduction. Down East: The Magazine of Maine. Camden Maine: Down East Magazine Volume Number: 56, Issue Number: 12. Issue Date: July 2010. Page Number: 54-57, 75-77
Article Scope: Entry and reproduction. Winslow Homer : A Retrospective Exhibition. Boston, MA: Museum of Fine Arts, Boston, 1959.
Article Scope: Mention and reproduction. Thomas Denenberg, ed. Weatherbeaten: Winslow Homer and Maine. New Haven, CT: Yale University Press, 2012.
Report: The Winslow Homer Studio Campaign. Portland, ME: Portland Museum of Art, 2012.
The Boston Globe. Boston, MA
Article Author: Vega, Julius. Article Title: The Artist's Studio in an Afternoon Fog. Article Scope: Poetry. Community Voices in the Gallery: a Collection of Writings by Members of our Community Inspired by Works of Art at the Memorial Art Gallery of the University of Rochester. Rochester, NY: Memorial Art Gallery, 2009. Page Number: 54
Article Scope: Exhibition Checklist. Century Loan Exhibition. Prout's Neck, ME: Prout's Neck Association, 1936.
Article Author: O'Gorman, James F.. Article Title: Winslow Homer's Maine Studio. Article Scope: Mention and reproduction. Nineteenth Century. Volume Number: 33, Issue Number: 2. Issue Date: Fall 2013. Page Number: 3
Article Scope: Mention and reproduction. Winslow Homer and the New England Coast. New York, NY: Whitney Museum of American Art, 1984.
Article Scope: Mention and reproduction. Mr. James A. Ganz, ed. Jewel City: Art from San Francisco's Panama-Pacific International Exposition. San Francisco, CA: Fine Arts Museums of San Francisco, 2015.
Article Scope: Mention and reproduction. Marjorie Searl and Lu Harper. The Memorial Art Gallery: 100 Years. Rochester, NY: Memorial Art Gallery, 2013.
Article Scope: Reproduction only. Dana E. Byrd and Frank H. Goodyear, III. Winslow Homer and the Camera. Brunswick, ME: Bowdoin College Museum of Art, 2018.
Article Scope: Mention and reproduction. Karl Kusserow and Alan C. Braddock. Nature's Nation: American Art and Environment. New Haven, CT: Yale University Press, 2018.
Article Scope: Reproduction only. Anne Collins Goodyear and Frank H. Goodyear, III. At First Light: Two Centuries of Maine Artists, their Homes and Studios. New York, NY: Rizzoli Electa, 2020.
Article Scope: Discussion and reproduction. William R. Cross. Winslow Homer: American Passage. New York, NY: Farrar, Straus and Giroux, 2022.
Christine Riding and Christopher Riopelle. Winslow Homer: Force of Nature. London, England: National Gallery Global, 2022.
19th Century American Art
Acquisitions from the R. T. Miller, Jr. Fund
Audio Tour Excerpts
Director's Audio Tour
MAG Favorites
Objects with Audio Interpretation
Selected Work Purchased with Funds from R.T. Miller, Jr.
Web Links See links to web pages and lesson plans
Seeing America Inservice Materials from a teacher in-service presentation Spring 2008
Seeing America Chapter on Winslow Homer's The Artist's Studio in an Afternoon Fog, written by David Tatham.
Your current search criteria is: Exhibition is "Milestones in American Art" and [Object]Century is "19th Century".


1989 Italian Government Award for Research at the University of Bologna.
I have been enormously impressed with her dedication and seriousness as a scholar. There are very few members in this faculty of 130 members who approach her in the seriousness of her academic pursuits. In addition, I have been very impressed with her wide range of interests and expertise. She moves with great facility from music to literature to philosophy to other fields as well. Most recently, I attended her lecture on the Second Viennese School which happens to be a great interest of my own. Though there are very many obvious attractions of the music of this period, it is very difficult to put it into an intelligible, cultural context. I must say that Dr. Bratuz succeeded in doing this admirably.
Dr Bratuz is the rarest of performers, since her interest has always lain not simply in transmitting a technique of pianism to her students, but also in enlightening them about the ideals of philosophy and aesthetics, and the nature of musical utterance. The result of the interaction of her personal faith in music and the personality of her students has been, in my observation, that those students with the greatest intellectual capacity have attached themselves to her and have learned from her what few others are capable of teaching. Dr.Bratuz is herself filled with a spirit of enquiry, and has communicated that spirit to the elect among her students. Over the years her contribution to this Faculty of Music has been in the unparalleled enrichment which she has constantly offered to her students and her colleagues alike.


text:
#include "precomp.hpp"

// ----------------------------------------------------------------------
// CLAHE

namespace
{
    class CLAHE_CalcLut_Body : public cv::ParallelLoopBody
    {
    public:
        CLAHE_CalcLut_Body(const cv::Mat& src, cv::Mat& lut, cv::Size tileSize, int tilesX, int clipLimit, float lutScale) :
            src_(src), lut_(lut), tileSize_(tileSize), tilesX_(tilesX), clipLimit_(clipLimit), lutScale_(lutScale)
        {
        }

        void operator ()(const cv::Range& range) const;

    private:
        cv::Mat src_;
        mutable cv::Mat lut_;

        cv::Size tileSize_;
        int tilesX_;
        int clipLimit_;
        float lutScale_;
    };

    void CLAHE_CalcLut_Body::operator ()(const cv::Range& range) const
    {
        const int histSize = 256;

        uchar* tileLut = lut_.ptr(range.start);
        const size_t lut_step = lut_.step;

        for (int k = range.start; k < range.end; ++k, tileLut += lut_step)
        {
            const int ty = k / tilesX_;
            const int tx = k % tilesX_;

            // retrieve tile submatrix

            cv::Rect tileROI;
            tileROI.x = tx * tileSize_.width;
            tileROI.y = ty * tileSize_.height;
            tileROI.width = tileSize_.width;
            tileROI.height = tileSize_.height;

            const cv::Mat tile = src_(tileROI);

            // calc histogram

            int tileHist[histSize] = {0, };

            int height = tileROI.height;
            const size_t sstep = tile.step;
            for (const uchar* ptr = tile.ptr<uchar>(0); height--; ptr += sstep)
            {
                int x = 0;
                for (; x <= tileROI.width - 4; x += 4)
                {
                    int t0 = ptr[x], t1 = ptr[x+1];
                    tileHist[t0]++; tileHist[t1]++;
                    t0 = ptr[x+2]; t1 = ptr[x+3];
                    tileHist[t0]++; tileHist[t1]++;
                }

                for (; x < tileROI.width; ++x)
                    tileHist[ptr[x]]++;
            }

            // clip histogram

            if (clipLimit_ > 0)
            {
                // how many pixels were clipped
                int clipped = 0;
                for (int i = 0; i < histSize; ++i)
                {
                    if (tileHist[i] > clipLimit_)
                    {
                        clipped += tileHist[i] - clipLimit_;
                        tileHist[i] = clipLimit_;
                    }
                }

                // redistribute clipped pixels
                int redistBatch = clipped / histSize;
                int residual = clipped - redistBatch * histSize;

                for (int i = 0; i < histSize; ++i)
                    tileHist[i] += redistBatch;

                for (int i = 0; i < residual; ++i)
                    tileHist[i]++;
            }

            // calc Lut

            int sum = 0;
            for (int i = 0; i < histSize; ++i)
            {
                sum += tileHist[i];
                tileLut[i] = cv::saturate_cast<uchar>(sum * lutScale_);
            }
        }
    }

    class CLAHE_Interpolation_Body : public cv::ParallelLoopBody
    {
    public:
        CLAHE_Interpolation_Body(const cv::Mat& src, cv::Mat& dst, const cv::Mat& lut, cv::Size tileSize, int tilesX, int tilesY) :
            src_(src), dst_(dst), lut_(lut), tileSize_(tileSize), tilesX_(tilesX), tilesY_(tilesY)
        {
        }

        void operator ()(const cv::Range& range) const;

    private:
        cv::Mat src_;
        mutable cv::Mat dst_;
        cv::Mat lut_;

        cv::Size tileSize_;
        int tilesX_;
        int tilesY_;
    };

    void CLAHE_Interpolation_Body::operator ()(const cv::Range& range) const
    {
        const size_t lut_step = lut_.step;

        for (int y = range.start; y < range.end; ++y)
        {
            const uchar* srcRow = src_.ptr<uchar>(y);
            uchar* dstRow = dst_.ptr<uchar>(y);

            const float tyf = (static_cast<float>(y) / tileSize_.height) - 0.5f;

            int ty1 = cvFloor(tyf);
            int ty2 = ty1 + 1;

            const float ya = tyf - ty1;

            ty1 = std::max(ty1, 0);
            ty2 = std::min(ty2, tilesY_ - 1);

            const uchar* lutPlane1 = lut_.ptr(ty1 * tilesX_);
            const uchar* lutPlane2 = lut_.ptr(ty2 * tilesX_);

            for (int x = 0; x < src_.cols; ++x)
            {
                const float txf = (static_cast<float>(x) / tileSize_.width) - 0.5f;

                int tx1 = cvFloor(txf);
                int tx2 = tx1 + 1;

                const float xa = txf - tx1;

                tx1 = std::max(tx1, 0);
                tx2 = std::min(tx2, tilesX_ - 1);

                const int srcVal = srcRow[x];

                const size_t ind1 = tx1 * lut_step + srcVal;
                const size_t ind2 = tx2 * lut_step + srcVal;

                float res = 0;

                res += lutPlane1[ind1] * ((1.0f - xa) * (1.0f - ya));
                res += lutPlane1[ind2] * ((xa) * (1.0f - ya));
                res += lutPlane2[ind1] * ((1.0f - xa) * (ya));
                res += lutPlane2[ind2] * ((xa) * (ya));

                dstRow[x] = cv::saturate_cast<uchar>(res);
            }
        }
    }

    class CLAHE_Impl : public cv::CLAHE
    {
    public:
        CLAHE_Impl(double clipLimit = 40.0, int tilesX = 8, int tilesY = 8);

        cv::AlgorithmInfo* info() const;

        void apply(cv::InputArray src, cv::OutputArray dst);

        void setClipLimit(double clipLimit);
        double getClipLimit() const;

        void setTilesGridSize(cv::Size tileGridSize);
        cv::Size getTilesGridSize() const;

        void collectGarbage();

    private:
        double clipLimit_;
        int tilesX_;
        int tilesY_;

        cv::Mat srcExt_;
        cv::Mat lut_;
    };

    CLAHE_Impl::CLAHE_Impl(double clipLimit, int tilesX, int tilesY) :
        clipLimit_(clipLimit), tilesX_(tilesX), tilesY_(tilesY)
    {
    }

    CV_INIT_ALGORITHM(CLAHE_Impl, "CLAHE",
        obj.info()->addParam(obj, "clipLimit", obj.clipLimit_);
        obj.info()->addParam(obj, "tilesX", obj.tilesX_);
        obj.info()->addParam(obj, "tilesY", obj.tilesY_))

    void CLAHE_Impl::apply(cv::InputArray _src, cv::OutputArray _dst)
    {
        cv::Mat src = _src.getMat();

        CV_Assert( src.type() == CV_8UC1 );

        _dst.create( src.size(), src.type() );
        cv::Mat dst = _dst.getMat();

        const int histSize = 256;

        lut_.create(tilesX_ * tilesY_, histSize, CV_8UC1);

        cv::Size tileSize;
        cv::Mat srcForLut;

        if (src.cols % tilesX_ == 0 && src.rows % tilesY_ == 0)
        {
            tileSize = cv::Size(src.cols / tilesX_, src.rows / tilesY_);
            srcForLut = src;
        }
        else
        {
            cv::copyMakeBorder(src, srcExt_, 0, tilesY_ - (src.rows % tilesY_), 0, tilesX_ - (src.cols % tilesX_), cv::BORDER_REFLECT_101);

            tileSize = cv::Size(srcExt_.cols / tilesX_, srcExt_.rows / tilesY_);
            srcForLut = srcExt_;
        }

        const int tileSizeTotal = tileSize.area();
        const float lutScale = static_cast<float>(histSize - 1) / tileSizeTotal;

        int clipLimit = 0;
        if (clipLimit_ > 0.0)
        {
            clipLimit = static_cast<int>(clipLimit_ * tileSizeTotal / histSize);
            clipLimit = std::max(clipLimit, 1);
        }

        CLAHE_CalcLut_Body calcLutBody(srcForLut, lut_, tileSize, tilesX_, clipLimit, lutScale);
        cv::parallel_for_(cv::Range(0, tilesX_ * tilesY_), calcLutBody);

        CLAHE_Interpolation_Body interpolationBody(src, dst, lut_, tileSize, tilesX_, tilesY_);
        cv::parallel_for_(cv::Range(0, src.rows), interpolationBody);
    }

    void CLAHE_Impl::setClipLimit(double clipLimit)
    {
        clipLimit_ = clipLimit;
    }

    double CLAHE_Impl::getClipLimit() const
    {
        return clipLimit_;
    }

    void CLAHE_Impl::setTilesGridSize(cv::Size tileGridSize)
    {
        tilesX_ = tileGridSize.width;
        tilesY_ = tileGridSize.height;
    }

    cv::Size CLAHE_Impl::getTilesGridSize() const
    {
        return cv::Size(tilesX_, tilesY_);
    }

    void CLAHE_Impl::collectGarbage()
    {
        srcExt_.release();
        lut_.release();
    }
}

cv::Ptr<cv::CLAHE> cv::createCLAHE(double clipLimit, cv::Size tileGridSize)
{
    return new CLAHE_Impl(clipLimit, tileGridSize.width, tileGridSize.height);
}

redpajama_set_name: RedPajamaGithub


Come home to this pleasant- tasting and relaxing tea. Excellent after a hard day at work or play. It is soothing and calming to the nervous system. Can be used to assist with sleeping.
enzymes. Peppermint stimulants, Alfalfa tones, and Buckthorn herbs keep the bowels regularwhile improving digestion in general.
Great, refreshing tea for hot summer days! Green tea is a great antioxidant which helps to keep the immune system strong. Peppermint promotes digestive health.
Have you ever wondered how the Chinese women stay so slim? They drink this old fashioned tea!
YerbaMate tea is a mild, pleasant tasting tea which stimulants the adrenal glands to produce natural cortisone and adrenalin. Comes pre-sweetened with Stevia for those with yeast problems.
Excellent blood cleansing tea. Good for spring cleaning the system to remove toxins.
Tea. This tea is perfect for a mild spring blood cleanser.
Sit back and imagine yourself on a tropical beach while enjoying this most refreshing and healing beverage. One of the main ingredients is hibiscus which strengthens the kidneys, helps with blood pressure and has a very mild taste. Combine that with the other delicious ingredients and you are in paradise! Makes 2 quarts.


text:
/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/include/usr/targeting/common/targetservice.H $            */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2012,2017                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* 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.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
#ifndef __TARGETING_COMMON_TARGETSERVICE_H
#define __TARGETING_COMMON_TARGETSERVICE_H

/**
 *  @file targeting/common/targetservice.H
 *
 *  @brief Interface for the target service
 *
 *  This header file contains the interface definition for the target service
 *  which is responsible for configuring and aggregating the pool of valid
 *  targets, and providing services to access targets based on various criteria
 */

//******************************************************************************
// Includes
//******************************************************************************

// STD
#include <stdint.h>
#include <stdlib.h>
#include <vector>

// This component
#include <targeting/common/attributes.H>
#include <attributetraits.H>
#include <targeting/common/iterators/iterators.H>
#include <targeting/common/predicates/predicates.H>
#include <targeting/adapters/types.H>
#include <targeting/common/error.H>
#include <pnortargeting.H>

//******************************************************************************
// Interface Definitions
//******************************************************************************

//******************************************************************************
// Method to access the targeting service externally
//******************************************************************************

namespace TARGETING
{
    class TargetService;

    /*
     * @brief -  typedef for node Id
     */
    typedef uint8_t NODE_ID;

    /* Node 0 */
    static const NODE_ID NODE0 = 0x00;

    /* Invalid Node Id  - to initialize struct variable*/
    static const NODE_ID INVALID_NODE = 0xFF;

    /* Invalid Section Id - to initialize struct variable */
    static const uint8_t INVALID_SECTIONID  = 0xFF;

    // Special "not found" fabric group ID is the data type with all bits set
    static const ATTR_FABRIC_GROUP_ID_type FABRIC_GROUP_ID_NOT_FOUND =
        INVALID_NODE;

    /**
     *  @brief Struct specifying different parameters required for section data
     *  update on the sectionId/NodePtr.
     *
     *  Given a struct with the following elements required to point to a
     *  specific section in a given node and the dataPtr to be updated.
     *  Size of the data is always the Page size i.e. 4K
     *
     *  Struct element details -
     *  sectionId - Section Id
     *  nodeId  - Node Id
     *  pageNumber - PageNumber for the section.
     *  padBytes - PadBytes to fill in 2 extra bytes
     *  dataPtr - Data Ptr
     *  pNodeTarget - Node Targeting Ptr
     *
     */

    struct sectionRefData
    {
        sectionRefData() :
            sectionId(0x00),
            nodeId(INVALID_NODE),
            pageNumber(0),
            dataPtr(NULL),
            pNodeTarget(NULL)
        {
        }

        uint8_t  sectionId;
        uint8_t  nodeId;
        uint8_t  pageNumber;
        uint8_t  padBytes;
        uint8_t* dataPtr;
        Target*  pNodeTarget;
    };

    /**
     *  @brief Returns a reference to the targeting service singleton
     *
     *  @return Reference to the targeting service
     */
    TARGETING::TargetService& targetService();

/**
 *  @brief Sentinel representing the master processor chip target early in
 *      host boot prior to initialization of the target service.  Needed by the
 *      DD framework to bring PNOR device driver online.  Note this target
 *      cannot be used as input to any target service APIs.
 */
extern Target* const MASTER_PROCESSOR_CHIP_TARGET_SENTINEL;

/**
 *  @brief TargetService class
 *
 *  This class manages the set of possible targets and provides facility to
 *  access specific targets, based on given criteria
 */
class TargetService
{
    public:

        /**
         *  @brief Enum specifying the recursion depth for target searching
         *
         *  Indicates whether to return only IMMEDIATE children/parent of a
         *  target, or ALL children/parents of a target
         */
        enum RECURSION_LEVEL
        {
            IMMEDIATE = 0x01, ///< Return immediate children/parent of a target
            ALL       = 0x02, ///< Return all children/parents of a target
        };

        /**
         *  @brief Enum specifying the type of association between targets
         *
         *  Indicates what relationship the result target should have to the
         *  target in question
         */
        enum ASSOCIATION_TYPE
        {
            PARENT,             ///< The result target(s) should be parents by
                                ///< containment
            CHILD,              ///< The result target(s) should be children by
                                ///< containment
            PARENT_BY_AFFINITY, ///< The result target(s) should be the parents
                                ///< by hardware affinity
            CHILD_BY_AFFINITY,  ///< The result target(s) should be children by
                                ///< Hardware affinity.  For example the child
                                ///< of a memory controller channel target might
                                ///< be a DIMM target
            PERVASIVE_CHILD,    ///< The result target(s) should be units
                                ///< associated with a pervasive target
            PARENT_PERVASIVE,   ///< The result target should be a pervasive
                                ///< target
            MAX_ASSOCIATION_TYPES, ///< Number of types, must always be last
        };

    public:

        /**
         *  @brief Construct the target service
         *
         *  Constructs the target service, but does not actually initialize the
         *  target pool
         *
         *  @post Target service instantiated, but target pool not initialized
         */
        TargetService();

        /**
         *  @brief Destroys the target service
         *
         *  Destroys the target service; it should never be run since it hides
         *  behind a singleton, but is included for completeness
         *
         *  @post Target service is destroyed, and all owned resources are
         *      reclaimed
         */
        ~TargetService();

        /**
         *  @brief Initializes the target service
         *
         *  @par Detailed Description:
         *  Initializes the target service, including determining maximum number
         *  of targets, setting up the target pool, etc. for each node in the
         *  system blueprint local to the subsystem. Should be called once PNOR
         *  is accessible and can be mapped
         *
         *  @param[in] i_maxNodes, max number of nodes to initialize within the
         *      targetservice.
         *
         *  @pre N/A
         *
         *  @post Target service initialized with all possible targets. User
         *      would need to call targetservice().initDefaultMasterNode to make
         *      targetservice fully initialized and ready to be used.
         */
        void init(const size_t i_maxNodes = 1);

        /**
         *  @brief Returns whether target service has initialized or not
         *
         *  @return bool indicating whether service has initialized or not
         *  @retval true Service has initialized and can be used
         *  @retval false Service has not initializated and should not be used
         *      (other than to run the initialization)
         */
        bool isInitialized() const
        {
            return iv_initialized;
        }

        /**
         *  @brief Map iterator types to common aliases
         */
        typedef TargetIterator         iterator;
        typedef ConstTargetIterator    const_iterator;
        typedef TargetRawIterator      rawiterator;
        typedef ConstTargetRawIterator const_rawiterator;

        /**
         *  @brief Return iterator which points to first target service target
         *      (or end() if none)
         *
         *  @return Iterator pointing to first target service target
         */
        iterator begin();

        /**
         *  @brief Return rawiterator which points to first target service
         *      target (or end() if none)
         *
         *  @return RawIterator pointing to first target service target
         */
        rawiterator raw_begin();

        /**
         *  @brief Return iterator to const which points to first target service
         *      target (or end() if none)
         *
         *  @return Iterator to const pointing to first target service target
         */
        const_iterator begin() const;

        /**
         *  @brief Return rawiterator to const which points to first target
         *      service target (or end() if none)
         *
         *  @return RawIterator to const pointing to first target service target
         */
        const_rawiterator raw_begin() const;

        /**
         *  @brief Return iterator which points to the "past the end of the
         *      list" target maintained by the target service
         *
         *  @return Iterator pointing to the "past the end of the list" target
         *      maintained by the target service
         */
        iterator end();

        /**
         *  @brief Return rawiterator which points to the "past the end of the
         *      list" target maintained by the target service
         *
         *  @return RawIterator pointing to the "past the end of the list"
         *      target maintained by the target service
         */
        rawiterator raw_end();

        /**
         *  @brief Return iterator to const which points to the "past the end of
         *      the list" target maintained by the target service
         *
         *  @return Iterator to const pointing to the "past the end of the list"
         *      target maintained by the target service
         */
        const_iterator end() const;

        /**
         *  @brief Return rawiterator to const which points to the "past the end
         *      of the list" target maintained by the target service
         *
         *  @return RawIterator to const pointing to the "past the end of the
         *      list" target maintained by the target service
         */
        const_rawiterator raw_end() const;

        /**
         *  @brief Allow iterator access to the target service's target store
         */
        friend class _TargetIterator<Target*>;
        friend class _TargetIterator<const Target*>;

        /**
         *  @brief Allow rawiterator access to the target service's target store
         */
        friend class _TargetRawIterator<Target*>;
        friend class _TargetRawIterator<const Target*>;

        /**
         *  @brief Returns the top level physical target
         *
         *  Returns the top level (usually system) target.  Caller must check
         *  for a NULL top level target
         *
         *  @param[out] o_targetHandle Top level target handle
         *
         *  @pre N/A
         *
         *  @post The returned handle is NULL if a top level target doesn't
         *      exist or service not initialized, otherwise it references a
         *      valid top level target
         */
        void getTopLevelTarget(
            Target*& o_targetHandle) const;

        /**
         *  @brief Returns whether specified entity path corresponds to a real
         *      target
         *
         *  Consults the specified entity path and searches through all
         *  available targets to find a matching entity path attribute.  If it
         *  finds a match, then the associated target exists, otherwise it does
         *  not exist
         *
         *  @param[in] i_entityPath Entity path to verify for existence
         *  @param[out] o_exists Whether the entity path corresponds to a
         *      target
         *
         *  @pre N/A
         *
         *  @post "true" returned to caller if specified entity path exists,
         *      "false" if not or service not initialized
         */
        void exists(
            const EntityPath& i_entityPath,
                  bool&       o_exists) const;

        /**
         *  @brief Returns a target handle which has an associated entity path
         *      matching the specified entity path
         *
         *  Returns a target handle which has an associated entity path
         *  matching the specified entity path.  Caller must check the
         *  returned handle for NULL.
         *
         *  @param[in] i_entityPath Entity path for which to find the matching
         *      target handle
         *
         *  @pre N/A
         *
         *  @post NULL returned to caller if no match was found or service
         *      not initialized, otherwise a valid handle returned
         *
         *  @return Target handle
         *
         *  @retval NULL No target match found
         *  @retval !NULL Handle to the corresponding target
         */
        Target* toTarget(
            const EntityPath& i_entityPath) const;

        /**
         *  @brief Returns the master processor chip target handle
         *
         *  Returns the master processor chip target handle.  On systems
         *  without an alternate master, it returns a handle to the only master,
         *  if found (NULL otherwise).  On systems with multiple potential
         *  masters, it returns a target handle to the acting master (NULL
         *  otherwise).  If targeting information is not yet accessible (very
         *  early in the host boot IPL), the returned target handle will be a
         *  sentinel value representing the master (whichever it may be)
         *
         *  @param[out] o_masterProcChipTarget Target handle referring to the
         *      current master processor chip (the one connected to PNOR)
         *  @param[in]  i_pNodeTarget
         *      Handle to the node target to search for the acting master
         *      processor.  If NULL, HB will search whatever node it's
         *      running on, and FSP will search the physical drawer containing
         *      the lowest ordered fabric node ID.         *
         *  @pre Target Service must be initialized
         *
         *  @post Master processor chip target returned or NULL is returned if
         *  targetservice is not yet initialized or user passed an invalid node
         *  target to get the master proc handle
         */
        void masterProcChipTargetHandle(
            Target*& o_masterProcChipTargetHandle,
            const Target* i_pNodeTarget = NULL) const;

        /**
         *  @brief Returns the master processor chip target handle
         *
         *  Returns the master processor chip target handle for the given (or
         *  defaulted) node.  On nodes without an alternate master,
         *  it returns a handle to the only master, if found (NULL otherwise).
         *  On nodes with multiple potential
         *  masters, it returns a target handle to the acting master (NULL
         *  otherwise).  If targeting information is not yet accessible (very
         *  early in the host boot IPL), the returned target handle will be a
         *  sentinel value representing the master (whichever it may be)
         *
         *  @param[out] o_masterProcChipTarget
         *      Target handle of acting master processor chip for the given
         *      node (the one connected to PNOR)
         *  @param[in] i_pNodeTarget
         *      Target handle of node to search.  If NULL, HB will search
         *      whatver node it's running on, andFSP will search the physical
         *      drawer containing the lowest orderd fabric node ID
         *
         *  @pre Target Service must be initialized
         *
         *  @post Master processor chip target returned or a dummy value
         *      representing the acting master processor chip if the targeting
         *      information is not yet initialized
         *
         *  @return Error log handle indicating the status of the request
         *
         *  @retval NULL  Success, Master Proc handle is returned to the user
         *  @retval !NULL Failure, Failed to find the Master Proc Handle & NULL
         *      is returned to user
         */
        errlHndl_t queryMasterProcChipTargetHandle(
                  Target*& o_masterProcChipTargetHandle,
            const Target*  i_pNodeTarget = NULL) const;

        /**
         *  @brief Returns whether the specified entity path attribute exists
         *      for a specified target, and if so, the value of that attribute
         *
         *  Returns whether the specified entity path attribute exists for a
         *  specified target, and if so, the value of that attribute.  If the
         *  target doesn't exist, or the attribute doesn't correspond to an
         *  entity path attribute, or the entity path attribute doesn't exist
         *  for the target, then the routine returns false and the entity path
         *  value is invalid.
         *
         *  @param[in] i_attr Entity path attribute to read
         *  @param[in] i_pTarget Target handle to read the attribute from
         *  @param[out] o_entityPath Value of the target's associated entity
         *      path value
         *
         *  @pre N/A
         *
         *  @post See "return"
         *
         *  @return bool indicating whether the specified attribute exists
         *      for the specified target and whether the returned entity path
         *      value is valid
         *
         *  @retval true Specified attribute exists, entity path is valid
         *  @retval false Specified attribute does not exist, entity path is
         *      invalid
         */
        bool tryGetPath(
                  ATTRIBUTE_ID i_attr,
            const Target*      i_pTarget,
                  EntityPath&  o_entityPath) const;

        /**
         *  @brief Returns handles to targets associated to the specified
         *      target in a specific way, in depth first order
         *
         *  Returns handles to targets associated to the specified target,
         *  as indicated by an association type.  Based on the specified
         *  recursion level, the routine will determine the immediate
         *  associations, or all possible associations.  For example, if caller
         *  supplies a processor chip target and asks for its children targets,
         *  the routine will return the next set of targets in the physical
         *  hierarchy.  Conversely if the caller asks for ALL children targets
         *  for said source target, the routine will return all targets
         *  contained within the processor chip.  All targets will be returned
         *  in depth first order.
         *
         *  @param[out] o_list List of target handles that match the specified
         *      criteria.  Caller's list will be cleared initially.
         *  @param[in] i_pTarget Target from which to search for other targets.
         *      Must not be NULL.
         *  @param[in] i_type Type of association linking the specified target
         *      to candidate result targets
         *  @param[in] i_recursionLevel Whether to return candidate targets
         *      immediately associated to the specified target or recursively
         *      associated to it.
         *  @param[in] i_pPredicate Pointer to a predicate to be evaluated
         *      against each candidate target (as determined by the source
         *      target, type, and recursion level parameters).  If the predicate
         *      returns true, the target will be added to the result list.  A
         *      value of NULL acts as a predicate that always returns true.
         *
         *  @pre N/A
         *
         *  @post Caller's list cleared; list of target handles matching the
         *      specified criteria returned
         */
         void getAssociated(
                  TargetHandleList& o_list,
            const Target* const     i_pTarget,
            const ASSOCIATION_TYPE  i_type = CHILD,
            const RECURSION_LEVEL   i_recursionLevel = IMMEDIATE,
            const PredicateBase*    i_pPredicate = NULL) const;

        /**
         *  @brief Dump the target service for debug only
         *
         *  @post Output written to buffer
         */
        void dump() const;

        /**
         *  @brief Updates the targeting/attribute section data with the
         *  specified vector parameters.
         *
         *  This is the top level interface, would basically call the lower
         *  level attribute resource provider interface. The lower level
         *  interface would fetch each vector element and update each section
         *  with corresponding data from the offset specified.
         *
         *  @param[in] i_pages, vector of sectionRefData struct
         *
         *  @pre N/A
         *
         *  @post See "return"
         *
         *  @return bool indicates whether the write to section data is
         *  successful or not.
         *
         *  @retval true Section Data update successful
         *  @retval false Section Data update failed.
         */
        bool writeSectionData(const std::vector<sectionRefData>& i_pages);

        /**
         *  @brief Fill up the vector with  the targeting/attribute section
         *  data specified in the sectionId parameter.
         *
         *  This is the top level interface, would basically call the lower
         *  level attribute resource provider interface. The lower level
         *  interface would fetch section data as per the sectionId specified
         *  and push to vector reference.
         *
         *  @param[out] o_pages, vector of sectionRefData struct
         *  @param[in] i_sectionId, section type
         *  @param[in] i_nodeId, node Id
         *
         *  @pre N/A
         *
         *  @post See "return"
         *
         *  @return void would fill up the vectore references with complete
         *  section data in pages.
         *
         */

        void readSectionData(std::vector<sectionRefData>& o_pages,
                const SECTION_TYPE i_sectionId,
                const NODE_ID i_nodeId = NODE0);

        /**
         *  @brief Get the Next initialized node in the Target Service
         *   This is to support the iterator
         *
         *  It takes the present node id as input and computes the next
         *  incremental caller-visible node available in the system and
         *  return it to the user
         *
         *  @param[in] i_nodeId, present node Id
         *
         *  @return returns uint8_t as next node
         *
         *  @retval success case, Node Id, returns the next incremental
         *  initialized caller-visible node available
         *  @retval, Failure case, invalid node, if the present node is the
         *  last initialized caller-visible node available in incremental
         *  order or user passed an invalid nodeId
         */
        NODE_ID getNextInitializedNode(const NODE_ID i_node) const;

        /**
         *  @brief Get the Next caller-visible Target Handle in incremental
         *  order. This is to support the iterator.
         *
         *  It is take a target handle as input and compute the next incremental
         *  available caller-visible target handle in the system and return it
         *  to the user.
         *
         *  @param[in] i_pTarget, non-NULL Target Handle
         *
         *  @return Target Handle
         *
         *  @retval Target*, returns the next incremental caller-visible
         *   Target Handle
         *  @retval NULL, if the target handle passed is the last visible
         *  target handle available in incremental order in the target service.
         */
        Target* getNextTarget(const Target* i_pTarget) const;

        /**
         *  @brief Sets the isMasterNode Attribute to the Node Target handle
         *  Passed and takes care of syncing master node's system target handle
         *  with non-master system target handles.
         *
         *  @par Detailed Description
         *  It takes the node target handle as input which is required to set as
         *  master node and sets the isMasterNode Attribute associated to true
         *  and also unset the isMasterNode associated with all current master
         *  node target handle. Along with this it also takes care of syncing
         *  master node's system target attributes with non-master node system
         *  target's attribute in the system.
         *
         *  @param[in] i_pTarget, Non-Null Node Target handle
         *
         *  @return error handle is return
         *  @retval Success case, NULL is returned means the master node set and
         *  sync is successful
         *  @return, Failure case, !NULL error handle is returned means the
         *  master node couldn't be set as desired.
         */
        errlHndl_t setMasterNode(const Target* i_pTarget);

        /**
         *  @brief this gives the information whether a system target is
         *  master-node's system target or non-master-node's system target
         *
         *  It is takes system target handle as input and checks whether the
         *  system target is from master-node target tree or non-master node
         *  target tree.
         *
         *  @param[in] i_pTarget, Non-Null System Target handle
         *
         *  @return true, means the system target passed is a non-master node's
         *  system target.
         *  @return false, means the system target passed is a master node's
         *  system target.
         */
        bool isNonMasterNodeSystemTarget(const Target* i_pTarget) const;

        /*
         *  @brief give the total number of nodes in the targeting service
         *  for which node level binaries have been initialized .
         *
         *  @return total number of nodes in the targeting model initiailized.
         */
        uint8_t getNumInitializedNodes() const;

        /**
         *  @brief set the default Master Node and release the intialize flag
         *  for targetservice
         *
         *  @par Detailed Description:
         *  Searches for previous instance of master node, else sets the default
         *  node (i.e. first initialized node) as master node. And then releases
         *  the initialized flag of targetservice, Intializing targetservice
         *  fully
         *
         *  @pre targetservice().init() should have been called before this.
         *
         *  @post Target service is fully initialized along with a default
         *  master node.
         */

        void initDefaultMasterNode();

        /**
         *  @brief Returns the Node Target handle of the Master node in the
         *  system.
         *
         *  @par Detailed Description:
         *  Returns the Node Target handle of the Master node in the system.
         *  Caller must check for NULL Target handle
         *
         *  @param[out] o_masterNodeTarget node target handle of the master node
         *  in the system
         *
         *  @pre TargetService must be initialized.
         *
         *  @post Returns the node target handle of the master node. User
         *  will always get a valid target else targetservice will assert.
         *
         *  @return void
         */
        void getMasterNodeTarget(Target*& o_masterNodeTarget) const;

    private:

        /**
         *  @brief Structure, Node information specific
         */
        struct NodeSpecificInfo
        {

            NodeSpecificInfo() :
                nodeId(INVALID_NODE),
                initialized(false),
                isMasterNode(false),
                targets(NULL),
                maxTargets(0),
                pPnor(NULL)
            {
            }

            NODE_ID     nodeId;       ///< Node Id for the binary file
            bool        initialized;  ///< Is service initialized or not
            bool        isMasterNode; ///< Is this the master node
            Target      (*targets)[]; ///< Pointer to array of target objects
            uint32_t    maxTargets;   ///< Maximum # target objects in the array
            const void* pPnor;        ///< Pointer to the PNOR targeting section
        };

        /**
         *  @brief Node Specific information container
         */
        typedef std::vector< NodeSpecificInfo > NodeInfo_t;

        /**
         *  @brief Returns the first Target from the first initialized node
         *  from the pool of targets.
         *
         *  param[out] o_firstTargetPtr First Target handle
         *
         *  @pre Target service must be initialized
         *
         *  @post Target Service returns the first Target from the first
         *  initialized node.
         *
         *  @returns void
         */
        void _getFirstTargetForIterators (Target*& o_firstTargetPtr) const;

        /**
         *  @brief Configures the pool of targets
         *
         *  This function computes the maximum number of targets possible based
         *  on the PNOR (or override) image, and updates the target service to
         *  point to the start of the target array, wherever it may reside
         *
         *  @param[in] i_nodeInfoContainer, struct to contain all node
         *  specific information of the type NodeSpecificInfo. May refer to
         *  structure definition
         *
         *  @pre Target service must not be initialized
         *
         *  @post Target service target pool configured for access
         */
        void _configureTargetPool(NodeSpecificInfo& i_nodeInfoContainer);

        /**
         *  @brief Computes the maximum number of targets, caches the value
         *      and returns it to the caller
         *
         *  Computes the maximum number of targets possible based on the PNOR
         *  (or override) image and returns it to the caller
         *
         *  @param[in/out] io_nodeInfoContainer, struct to contain all node
         *  specific information of the type NodeSpecificInfo. May refer to
         *  structure definition
         *
         *  @pre Target service must not already be initialized
         *
         *  @post Target service updated with maximum target count in
         *  nodeContainer.
         *
         */
        void _maxTargets(NodeSpecificInfo & io_nodeInfoContainer);

        //@NEBA
        /**
         *  @brief Returns handles targets associated to the specified target in
         *      a specific way as indicated by the input parameters.  Returns
         *      results in depth first order.
         *
         *  Returns handles to targets associated to the specified target,
         *  as indicated by an association type.  Based on the specified
         *  recursion level, the routine will determine the immediate
         *  associations, or all possible associations.  For example, if caller
         *  supplies a processor chip target and asks for its children targets,
         *  the routine will return the next set of targets in the physical
         *  hierarchy.  Conversely if the caller asks for ALL children targets
         *  for said source target, the routine will return all targets
         *  contained within the processor chip.  All searching is performed as
         *  a depth first search.  This routine will not clear the caller's
         *  input list when returning results.
         *
         *  @param[out] o_list List of target handles that match the specified
         *      criteria, not cleared by this function.
         *  @param[in] i_pSourceTarget Target from which to search for other
         *      targets.  Must not be NULL.  Function presumes caller has
         *      already screened out NULL targets.
         *  @param[in] i_type Type of association linking the specified target
         *      to candidate result targets
         *  @param[in] i_recursionLevel Whether to return candidate targets
         *      immediately associated to the specified target or recursively
         *      associated to it.
         *  @param[in] i_pPredicate Pointer to a predicate to be evaluated
         *      against each candidate target (as determined by the source
         *      target, type, and recursion level parameters).  If the predicate
         *      returns true, the target will be added to the result list.  A
         *      value of NULL acts as a predicate that always returns true.
         *
         *  @pre Input target must not be NULL
         *
         *  @post List of target handles matching the specified criteria
         *      added to end of caller's list
         */
        void _getAssociationsViaDfs(
                  TargetHandleList&    o_list,
            const Target* const        i_pSourceTarget,
            const ASSOCIATION_TYPE     i_type,
            const RECURSION_LEVEL      i_recursionLevel,
            const PredicateBase* const i_pPredicate) const;

        /**
         *  @brief Computes and stores the Top Level Target into iv_pSys
         *
         *  this should only be called to the exclusion of threads that might
         *   try to read or write iv_pSys.
         *
         *  @param NONE
         *
         *  @pre Target service must already be 'initialized'
         *
         *  @post Target service iv_pSys initialized with top TYPE_SYS
         *  target.
         *
         */
        void _setTopLevelTarget();

        // Instance variables
        bool        iv_initialized; ///< Is service initialized or not
        Target      * iv_pSys;      // Top Level Target

        NodeInfo_t iv_nodeInfo;

        // Disable copy constructor / assignment operator

        TargetService(
            const TargetService& i_right);

        TargetService& operator=(
            const TargetService& i_right);
};

/**
 *  @brief Singleton to access the only TargetService; deemphasized
 *      intentionally
 */
class TargetService;

TARG_DECLARE_SINGLETON(TARGETING::TargetService,theTargetService);

} // End namespace TARGETING

#endif // __TARGETING_COMMON_TARGETSERVICE_H


text:
Q: What do I need to know in order to help with bug/papercut fixing? I think the question is clear enough. One thing though, I'm interested in the programming part not something else.

A: You'll find this 'How To Fix a bug' wiki page quite useful. It mentions about how to generate a patch or a branch merge with the fix.
Programming skills required depend on the application or the bug you are working on.
If the bug is just a simple wording change you don't require much programming knowledge, just patience for Finding the line. ;)
I'd suggest you first have a look at the list of bugs, when you find something interesting, it will give you a better idea of what is required to fix that bug.
While working on a bug, make sure you mark the bug as In-Progress, as mentioned in the  papercuts wiki.
If you have any questions while working on a bug, feel free to ask on the Papercuts Ninja mailing list.

redpajama_set_name: RedPajamaStackExchange


Gabriel E. Sella, MD, MPH, M.Sc. Ph.D (HC), BCIA, DACPM, FAAFP, FAADEP, is a world expert in Surface Electromyography . Dr. Sella's Clinical SEMG assessment protocols offer a unique muscle evaluation process. The entire protocol takes approximately 10-20 minutes to complete. The Clinical SEMG Protocols Limited Edition software suite published by the BFE and de-signed by Dr. Sella records surface electromyography measures using Dr. Sella`s techniques and proprietary database. The software provides a report of SEMG activity and a pathway for SEMG biofeedback for rehabilitation. The suite addresses the importance of muscle assessment and is based on Dr. Sella s book entitled "Muscles in Motion". The software, only allows recording of an initial assessment and printing a report for specific elbow protocols.


This post shows more from the photography workshop on Cape Ann in September 2013. We went to Rockport harbor the evening of the second day for moonrise, then returned for sunrise on the third day. Yes, sometimes photographers don't get much sleep! What we saw ranged from a little girl enjoying ice cream on the rocks to various views of "Motif #1," seemingly a photographer's favorite. This is a rebuilt version of a lobster shack, rebuilt only for show, as it no longer processes lobsters. It exists for the enjoyment of tourists. One member of our group is shown here as she takes an interesting shot of her shadow on Motif #1. Many boats are secured at the harbor, ranging from sailboats and yachts to fishing vessels and colorful rowboats. Someone living by the harbor seems to have a jump on Christmas decorations. All activity is supervised by a great black-backed gull, who seems to think he's the harbor master. Enjoy!
It's good to be in plumbing! At least it was good for Robert Teller Crane, Jr. Next time you're in a water closet, look at the name on the fixtures. RT Crane, Sr., founded a foundry in Chicago. Upon his death and the split between his two sons, RT Crane, Jr. took over the helm and moved into the production of plumbing fixtures for the home. Actually, the company had been producing plumbing fixtures since 1896, but the demand for indoor plumbing and more luxurious bathrooms took off in the 1920s. RT Crane, Jr. was at the helm during this boon and saw to it that the company responded to this new market demand. Having become quite wealthy as a result, he eventually purchased 165 acres in Ipswich, Massachusetts. The property is now run by the Trustees and consists of two parts: Castle Hill and a wildlife refuge.
In September I participated in a photography workshop on Cape Ann, Massachusetts. We shot sunrises and sunsets, visited Halibut Point State Park and the Crane Estate, and walked around the harbor in Gloucester, among other things. This post shows some of my photos from the first day. We began with the sunrise at Rockport, then went to Halibut State Park and walked around the quarry, and finished the day with the sunset. During our sunset time a young woman was sitting on the rocks holding a scarf in the wind. The slideshow includes a meditative shot of her resting.


text:
Harry Kane recovers from hamstring injury but Jose Mourinho admits Tottenham striker may not be match fit
By Jackson Cole
30th April 2020, 9:43 am
Harry Kane has recovered from his hamstring injury and could feature if the Premier League is able to restart, Tottenham boss Jose Mourinho has said.
Mourinho offered positive news on Kane, who has been out since New Year's Day, as well as midfielder Moussa Sissoko and January signing Steven Bergwijn.
Kane sustained the injury against Southampton on New Year's Day
"They are recovered from their injuries," Mourinho told Sky Sports. "So Harry Kane is not injured, Moussa Sissoko is not injured, Steven Bergwijn is not injured, but it is one thing not to be injured, it's another thing to be ready to play football.
"For them it is many, many, many weeks of injury and when the injuries were almost at an end, we stopped training (because of the coronavirus pandemic).
"I don't know, they don't know, we have to wait for the official and right permission for the players to train again in groups to see if they can come back to a normal competition level.
"So if we play this season, the remaining nine matches, it would be good for everyone of us, it would be good for football, it would be good for the Premier League if players of that quality can play the remaining matches."
Kane has recovered from his injury but Mourinho admits he probably isn't match fit
Mourinho spent time on Wednesday delivering fresh produce from Tottenham's training ground kitchen garden to the food distribution hub at the stadium.
The Portuguese admitted earlier this month that he had acted outside of Government protocol in the lockdown by meeting up for a one-to-one training session with midfielder Tanguy Ndombele on Hadley Common.
Mourinho is living with members of his coaching staff during the lockdown, and admits his culinary skills do not extend much beyond frying an egg.
"We try our best, we don't have our families with us but we are big friends, and friends are family," he said.
"We work a lot, and time flies and when it comes to cooking we try to make it as simple as possible. I am the fried egg specialist and the other guys they are a bit better than I am."
Jose Mourinho delivers essential goods to vulnerable people in Enfield struggling due to coronavirus
Mourinho admitted: "I miss football, but I prefer to say I miss our world, like I think we all do. Football is just part of my world. But we have to be patient, this is a fight that we all have to fight."
Premier League clubs will discuss the possibility of restarting competition in June when they gather for a shareholders meeting on Friday, and Mourinho hopes a way can be found to safely finish the 2019-20 season.
"If we play football behind closed doors I'd like to think that football is never behind closed doors," he said.
"With cameras, it means that millions and millions are watching. So if one day we walk into this empty stadium, it will not be empty, not at all."

redpajama_set_name: RedPajamaCommonCrawl


So you've eaten all the mince pies, it's all new year new me on social media, you join the gym to get fit and start cooking healthy meals…. But January ends and so has your motivation to keep up all this health and fitness malarkey!
A healthy lifestyle is just that, a lifestyle, it's not a phase or a fad diet, and if you really want to stick with it it has to be sustainable and enjoyable.
Make a list of short, medium and long term goals. They don't have to be crazy and unrealistic, it can be anything from being able to do one full push up in 2 months or to being able to run 10k in 6 months. I find if you have something to aim for and you see progression along the way then you're more likely to stick with the training and be determined to reach your goal. Once you reach your goal simply make a new one!
It can be as simple as talking to someone in a gym class, that's how I found mine! I personally find having someone to workout with makes fitness more enjoyable as it makes going to the gym feel more social. You can motivate each other, work on goals together, compliment on changes/progression in one another, talk about healthy meal ideas and check out local healthy cafes/restaurants together. I do workout on my own at times, especially when running, and I do enjoy my own company when I do but it's also nice and motivating to have someone there to exercise with.
Plan when you're going to exercise and prepare what you're going to eat.
If you want to make fitness part of your lifestyle regularly you need to include it in your daily/weekly routine. So even just making a note in your diary or calendar of the days and times you will be exercising for the week ahead might help.
Preparing your food is so important. It keeps you on track so you don't fall back onto buying a pre-packed sandwich and chocolate for lunchtime, or popping a ready meal in the microwave when you get home. If you want to live a healthy lifestyle then preparing your food has to be made a priority. Now I'm not talking a dozen tupperware boxes lined up and filled with chicken, rice and broccoli, to me that always looks very boring, but if that works for you then great! There's no right or wrong way to prepare food, its just prioritising time and thinking ahead about what you will eat, whether that's making a massive bowl of pasta salad that will last you a few lunches, or cooking extra of your dinner to have for lunch the next day.
Online or offline, Instagram or a diary, whatever suits you best!
Noticing changes in appearance can be difficult when you see yourself all the time. Taking photos of your body is a great way to see changes and progression. Whether thats for losing weight, gaining muscle or even just seeing a change in healthier skin.
Write down recipes and take snaps of your of your food. Even if the recipe is so easy, write it down and take a pic! That way when you're not sure on what to have for dinner you can just look through your phone or recipe book and find a super easy and healthy meal you've done in the past! Not everyone is a fan of taking photos of their food, you got to find what works for you, if thats taking photos and sharing them then go for it! I like sharing recipes and photos for inspiration and to prove that healthy meals can be quick and easy.
Another bonus of recording your journey on social media is being surrounded by like-minded people. Its so inspiring and motivating seeing others working for similar goals and sharing the same beliefs. You can connect with others, help each other out, find events that are going on, and lots more!
Next Post New to the gym?


text:
This is why men don't message first on Tinder, according to science
Moya Crockett
Society may traditionally expect men to make the first move, but this fascinating study has revealed a big difference in how men and women use dating apps.
Dating apps were supposed to make dating easier, weren't they? In the 'real world', figuring out if someone likes you or not is a process that can take weeks, if not months, of detective work. But on an app, everything was supposed to be simple. You swipe, they swipe, a conversation starts, and romance blossoms.
Except, of course, it rarely happens like that. If you've ever used Tinder or similar apps, you'll know that – more often than not – you'll get a match, and then… Nothing. Nada. Nobody says hello. And the person who once seemed to hold so much potential sits silently in your phone forevermore, like a spam email that you can't be bothered to open.
But why do people bother swiping right on Tinder if they don't want to actually speak to the person they matched with? It's a question that researchers in the UK, Italy and Canada set out to answer in a study.
Researchers from Queen Mary University of London, Sapienza University of Rome, and the Royal Ottowa Health Care Group created 14 fake Tinder profiles in London – male and female – and automatically liked everyone within 100 miles. They then waited to see how many people would swipe right in return – and how many of those would initiate conversation.
"Swipe left, SWIPE LEFT!"
The fake male profiles didn't do particularly well, matching with others just 0.6% of the time. The fake female profiles were much more popular, being liked by about 10% of other (mostly male) users.
Perhaps surprisingly, considering the still-pervasive cliché that men will make the first move, men were found to be much less likely to start a conversation with the decoy profiles. Only 7% of men who matched with a fake profile actually followed through with a message. In contrast, 21% of women who connected with a fake profile sent a message. (Overall, more men sent messages than women, but that was because the vast majority of matches came from men.)
The results are illuminating in showing us how men and women use Tinder differently. Men, according to the researchers, are much less discriminating in who they attempt to match with – that is, they're far more likely to swipe right. But once they've got a match, they're also much less inclined to contact the other person, implying that the thrill of getting a match is satisfying enough.
Women, conversely, tend to swipe right much less often – but when they do, they're more likely to initiate conversation, suggesting that women try to match with people that they are serious about connecting with.
"Yes, a match! No, of course I'm not going to message her"
The results, arguably, aren't that surprising. As the Washington Post points out, there's lots of anecdotal evidence for the phenomenon of swipe-happy men and choosier women. A follow-up survey of Tinder users has confirmed that about a third of men say that they "casually like most profiles" most of the time, while the overwhelming majority of women say that they only swipe right on profiles they're actually attracted to.
A little confusingly, the researchers warn that these behaviours could be self-reinforcing. That is, when men approach Tinder with all the restraint of a video game character wielding a machine gun, women who take a similar approach will quickly find themselves overwhelmed with attention – making them pickier. And if women only swipe right sparingly, men will become even less discerning about who they like, in order to increase their chances of getting a date. And so the cycle continues.
"This gaming of the system undermines its operation and likely leads to much confusion," the researchers write. To which we can only say – well, yeah.
Sign up for the latest news and must-read features from Stylist, so you don't miss out on the conversation.
By entering my email I agree to Stylist's Privacy Policy
Images: Unsplash - John Tuesday
Moya is Contributing Women's Editor at stylist.co.uk and Deputy Editor of Stylist Loves, Stylist's daily email newsletter.
Recommended by Moya Crockett
What is intuitive dating, and why are so many people talking about it?
The new approach will help to take the stress out of your search for love.
Lauren Geall
Tinder rolls out changes for "more meaningful connections"
Have you got swiping fatigue?
Lizzo just revealed what it's like to match with A-listers on celebrity Tinder
The most prolific man on the app is Matthew Perry, aka Chandler from Friends.
Hannah-Rose Yee
This dating trend will remind you how fun it is to be single
Bored of dating apps? This could be the solution.


text:
Queer Bingo Seeks Full Gaming License
The Organizers of the fundraiser "Queer Bingo" have put on hold the event so that they can prepare to receive the full gaming license from the Lottery Commission.
The Queer Bingo Fundraiser will benefit the Houston GLBT Community and is expected to restart on August 19. The successful fundraiser has drawn very large crowds since its launch almost six months ago.
The event is hosted by Community Center Officials and local drag entertainers and each event is presented in a particular theme. The prizes range from $50 dollars to $500 dollars.
The main beneficiary for said event would be the local community center for gay, lesbian, bisexual and transgender citizens of the community. The Community Center also serves as a meeting place for the organizations since 1986.
The Community Center officials have to apply for a gaming license from the Texas Lottery Commission because cash awards are presented by the organization to the players. Christopher Bown, Community Center President, said that there is a long process that an organization must go through in order to obtain a license so they are postponing the fundraiser for a while. One of the reasons would be that they need to spend time in Austin and attend some classes which are needed for the licensing.
According to Brown the Lottery Commission will send someone to inspect the facility of the Community Center and the Center would not be able to complete the required paperwork until July 15 so they really needed the time to accomplish all of it.
He also added that they have to postponed their operations for a while until their permanent license is release because their temporary license is only good for a six month operation.
According to the Lottery Commission's official website in which the Bingo Enabling Act can be found, any charity organization that wants to operate bingo on a daily basis or on a single occasion in a legalized area must first apply for a license to the Commission to conduct Charitable Bingo operations.
According to the Lottery Commission Officials, the Bingo Enabling Act was created to provide non-profit organizations the opportunity to raise funds for their projects by conducting bingo.
The Bingo Enabling Act also says the organization must meet criteria that "Determine that all charitable bingo funds are used for a lawful purpose. Promote and maintain the integrity of the charitable bingo industry throughout Texas."


text:
Turkey to seek new trade deal with post-Brexit UK
Turkiye, World, Economy, Europe
Turkey's trade ministry ready to open new free trade agreement negotiations during Brexit transition process
Dilara Hamit | 01.02.2020
Turkey's Trade Ministry on Saturday announced it was seeking new trade channels with the U.K. during the Brexit transition period.
Brexit negotiations between the EU and the U.K. concluded on Nov. 14, 2018, and a deal was reached on the withdrawal of the agreement, which took place on Jan. 31, 2020.
With the U.K. having officially left the EU, the transition period is expected to end on Dec. 31, 2020.
"During this period, the U.K. will be treated as an EU member country in terms of trade, thereby maintaining its position as a Customs Union partner for our country within the same period," the ministry said in a statement.
It added that during the transition period, a new trade agreement would be negotiated between the U.K. and EU to shape future relations.
The ministry said Turkey would open talks with the U.K. for a bilateral free trade deal through existing structures.
Brexit EU Turkey U.K.
EU welcomes 1st meeting between Turkiye, Armenia on normalization of relations
European stocks close week in red
EU rejects Russia's attempts to 'build spheres of influence' in Europe
Ghana 'delighted' following removal from EU money laundering list
Italy holds state funeral for EU parliament chief David Sassoli
UK foreign secretary hails 'good talks' with EU


A fan of arbitrage investment opportunities, Israel Englander employed long-short trading strategies to grow his hedge fund, Millennium Management into a global firm operating in over 10 countries across the globe. Today, Millennium uses a large number of traders working in teams focused on different strategies.
Equity long-short strategies are not without risks. Complete automated and cost-effective prime broker solutions for Hedge Funds with trading, clearing and reporting on over 100 markets worldwide.Even the professional traders employed by big hedge funds in the space have suffered double digit declines during the previous month.
The Future of Finance Content Council was established in January 2017 to assist with Future of Finance project content creation and dissemination. Find bios of the members here.
There are numerous hedge fund strategies and sub-strategies that exist within the hedge fund universe. While it is difficult to define every single category, there are eight major approaches that are commonly employed by hedge funds. It is important for investors to understand these basic concepts before they get into hedge fund investing. 1.
The strategies and techniques employed by "hedge funds" are so multitudinous that without looking inside the box it is impossible to know which one is in line with your investment objectives.
6/4/2015 · Empirical Characteristics of Dynamic Trading Strategies: The Case of Hedge Funds William Fung is not appropriate for performance attribution when applied to hedge fund managers who use dynamic trading strategies. 5. Hedge Funds Style Analysis. but it is not very informative on the nature of the trading strategies employed.
Investors have demanded more transparency from hedge funds strategies, even though top hedge fund managers do not want to show their cards and reveal their position. This is one of the best (and worst) tactics employed by managers over time. Strategy used to hedge funds trading debt. Man Vs Machine: Quantitative Hedge Fund Management.
© Trading strategies employed by hedge funds Binary Option | Trading strategies employed by hedge funds Best binary options.


text:
Events During the Week of May 1st through May 8th, 2011
Monday, May 2nd, 2011
Plasma Physics (Physics/ECE/NE 922) Seminar
"What can we learn from the glow? Optical emission spectroscopy (OES) diagnostics of non-equilibrium electron energy distributions in low-temperature plasmas"
Speaker: Amy Wendt, UW-Madison Dept. of Electrical & Computer Engineering
Tuesday, May 3rd, 2011
Chaos & Complex Systems Seminar
"GPU Accelerated Simulations of Chaotic PDEs"
Speaker: Jon Seaton, UW-Madison Dept. of Physics
Abstract: It is well known that chaos exists in systems of ordinary differential equations (ODEs), however, the study of chaos in partial differential equations (PDEs) remains rather new and unexplored. This is in part due to the computational resources needed to accurately simulate such systems. However, recent improvements of graphics processing units (GPUs) for use in general computing may provide a fast and economical way to solve complex systems such as PDEs. This talk will discuss the development of an algorithm which both numerically solves and determines the existence of chaos in nonlinear PDEs while utilizing the multiprocessor architecture of the GPU. This new method will aid in our search for simple examples of chaotic PDEs.
High Energy Seminar
NPAC (Nuclear/Particle/Astro/Cosmo) Forum
Exciting Prospects in the Study of the Ghostly Neutrino: the Reactor Anti-Neutrino Anomaly
Place: 4274 Chamberlin
Speaker: John G. Learned, University of Hawaii, Manoa
Abstract: While we have made great progress in understanding neutrinos, with all their surprises, it seems the fun may not be behind us, with new anomalies coming over the horizon. I will focus on the emerging "reactor anti-neutrino anomaly," and the potentially revolutionary implications, which may point towards the existence of new sterile neutrinos. Finally, I will describe a little detector we are building which relates to some of these issues.
Host: Karsten Heeger
Hilldale Lecture
"The Small Star Opportunity"
Speaker: Prof David Charbonneau, Harvard CfA
Abstract: When exoplanets are observed to transit their parent stars, we are granted direct estimates of their masses, radii, and (by inference) composition, and we can undertake studies of their atmospheres. I will begin by	summarizing the findings of the NASA EPOXI Mission, which re-used the Deep Impact Spacecraft to conduct a search for rocky worlds in a handful of known exoplanet systems. I will then report on the latest findings from	the NASA Kepler Mission, which is conducting a transit search of 160,000

Sun-like stars for rocky, habitable planets. I will then turn my attention to the particular opportunities afforded by nearby low-mass stars: TheMEarth Project uses an array of modest telescopes to search such stars for planets as small as 2 Earth radii in the stellar habitable zones. Should we succeed in identifying such worlds, their proximity to us would enable spectroscopic investigations of their atmospheres with facilities such as the James Webb Space Telescope.

Host: Astronomy Department
Physics & Astronomy Departments
Senior Send off Pizza Party
Place: Rooftop of Sterling Hall
Abstract: Pizza & Soda
(weather permitting)
Public 2011 Physical Sciences Hilldale Lecture
The Last Generation of Lonely Astronomers
Speaker: Dr David Charbonneau, Harvard Smithsonian Center for Astrophysics
Abstract: For centuries humans have gazed up at the stars and asked whether there are inhabited worlds other than our own. We are fortunate to live at the moment in history when we have the technological ability to answer that question. Astronomers have now uncovered hundreds of worlds orbiting nearby stars, and have studied the chemical content of their atmospheres.

However, those studies have been restricted to planets that are both too hot and too large to be likely abodes for life. The coming year offers the very real opportunity to detect small, temperate worlds similar to the Earth. Once identified, we will probe the atmospheres that enshroud these distant orbs for chemical evidence of biological activity.
R. G. Herb Condensed Matter Seminar
Complex Materials, Calorimetry, and Energy Landscapes
Speaker: Alexandra Navrotsky, University of California - Davis
Abstract: Freed from the "tyranny of equilibrium", modern synthetic solid state chemists are producing nanomaterials, metastable phases, cluster compounds, and mixed organic-inorganic materials in a wealth of structures with amazing properties. Calorimetric studies have shown that many of these polymorphs or closely related materials are in fact very similar in energy, tracing out "energy landscapes" as a function of density, crystallinity, hydration, or other parameters. This talk focuses on new experimental thermodynamic results in three classes of materials: (1) amorphous and crystalline carbonates in the CaCO3 - MgCO3 - H2O system, (2) zeolites, mesoporous silicas, and metal organic frameworks (MOF), and (3) polynuclear cluster compounds in aluminum and uranium based systems.
Host: Pupa Gilbert
The Development of Large Area Microchannel Plate Photodetectors
Speaker: Bob Wagner, Argonne
Abstract: The Large Area Picosecond Photodetector Development Collaboration is comprised of groups from three national laboratories, five U.S. universities, and two small U.S. companies working on a three-year project to develop a new generation of economical, large area (400 cm2) microchannel plate photomultipliers that can be tailored for a wide variety of applications in particle physics, medical imaging, and high energy astrophysics. In parallel with the development of the detector, a readout technology based on a switched capacitor array waveform sampling chip with time resolution in the 10 picosecond range is being developed that would allow particle identification by time-of-flight in the multi-GeV energy range. The basic photomultiplier incorporates a bialkali photocathode and a glass capillary microchannel plate pair functionalized by atomic layer deposition (ALD) to produce photoelectrons from incident visible light photons and produce gains of greater 106. Borosilicate glass capillary plates with pore size of 20-40 microns provide an inexpensive substrate compared to the standard lead-glass used in commercial microchannel plates. ALD allows the resistive and secondary emissive functions of the plates to be fabricated separately and economically. The collaboration is characterizing a variety of candidate materials for the coatings in order to optimize the gain and stability of the microchannel plates. Plates with gain of 50,000-70,000 at 1000V. bias have been produced on 33mm diameter substrates. The first 20cm by 20cm square glass capillaries were recently delivered to the project. Two alternatives for assembly and hermetic sealing of the photodetector are being pursued in parallel: a traditional ceramic housing with a strip line anode structure with embedded pins for signal output and high voltage connection, and an all borosilicate glass housing with a silk-screened silver strip line anode readout. The latter represents a potentially very inexpensive method of tube fabrication. An external printed circuit board with a matching strip line layout provides a means of transmitting the signal to the waveform sampling chips while maintaining a 50 ohm impedance from strip line to front-end input. The talk will review the history and current status of the project, summarize potential applications of the photodetector, and outline plans for the future development and production of the photomultiplier.
Host: Teresa Montaruli
Last Day of Class
First Results from the T2K Neutrino Oscillation Experiment
Speaker: Scott Oser, University of British Columbia
Abstract: The past decade has shown us that, contrary to expectations, neutrinos have both masses and mixings between flavors. In a study of contrasts, their masses are ridiculously small, but the rates at which neutrinos change from one flavor to another are remarkably large. T2K is a new experiment to study what happens to a beam of neutrinos as it passes through the Honshu island in Japan. By shoot a beam of muon neutrinos from Japan's Pacific coast to the Super-Kamiokande detector 295km away, T2K hopes to observe muon neutrinos turning into electron neutrinos. This measurement is the cornerstone of a long-term effort to determine if neutrinos and anti-neutrinos behave identically, and may ultimately address the question of why our universe is made of matter and not anti-matter. I will present the first oscillation results from T2K and report on the current status of the experiment, including recovery efforts after the March 11 earthquake.
Host: Heeger
"This Week at Physics" poster: http://www.physics.wisc.edu/twap/posters/2011/2011-05-02.pdf


text:
Q: Can `Array.find` use a default value if the callback function doesn't return anything truthy? I'm using Array.find in one of my JavaScript handlers, and discovered that sometimes there is no truthy test, and so the property gets set to undefined. I worked around it like this:
const previous = this.value;
this.value = this.values.find((value) => value.Id === event.detail.valueId);
if (!this.value) {
    this.value = previous;
}

Is there any way to give a default value to the find method so that if nothing is found it uses that as a fallback?

A: Yes, you can use the ?? syntax to return a result if your left hand statement is null or undefined
this.value = this.values.find((value) => value.Id === event.detail.valueId) ?? true;

This is called the nullish coalescing operator , and it's a more specific case of the previously common || because that one returns the right hand side value whenever something is "false", not only null or undefined (e.g. also when the LHS is 0 or false)

A: You can try to use a ternary operator.
const find_value = this.values.find((value) => value.Id === event.detail.valueId)
this.value = find_value ? find_value : previous


i have a right side Magnum Speaker housing in very nice condition.
rideing motorcycles, vol firefighter,makeing money.
03:55 PM - CanuckRob quoted psychodiablo in post Cutting Keys ?
10:43 PM - djh3 quoted psychodiablo in post Victory Oil-Change Kit - What if it's no longer sold?
06:32 AM - half_crazy quoted psychodiablo in post a lil more top end speed.
10:02 AM - half_crazy quoted psychodiablo in post a lil more top end speed.
08:37 PM - half_crazy quoted psychodiablo in post a lil more top end speed.
01:00 PM - IndyVictory quoted psychodiablo in post a lil more top end speed.
06:58 AM - half_crazy quoted psychodiablo in post a lil more top end speed.


Greenify Donate v3.9.9.1 build 39910 Full APK This is only a gift bundle which initiates some trial includes in the Greenify application. These highlights can be empowered in settings of Greenify.
A portion of these exploratory highlights are still in beginning time. They may not take a shot at all gadgets and ROMs. They are incorporated just for cutting edge clients with adequate information about what they extremely mean and how to accurately utilize them. These highlights may cause breakdown or crash in applications. In once in a while outrageous case, you may need to manufacturing plant reset your gadget to recoup. I will attempt my best to keep away from those circumstances, yet assume no liability for the conceivable outcomes.
It is sheltered to buy and introduce, since nothing is influenced until the point when any of the test highlights is empowered expressly.
Be careful, most framework applications are basic to the essential usefulness of your gadget, once greenified, you may lose some piece of ease of use. In the case of something terrible happens, degreenify the framework applications you as of late greenified and reboot, or deactivate this exploratory highlights of Greenify and reboot.
Android system is fixed to enable Greenify to perform hibernation and different activities without the moderate root schedule. Plus, Boost mode likewise enhances similarity of numerous highlights in Greenify.
Google benefit structure is fixed to permit the GCM (Google Cloud Message, a.k.a. C2DM) communicate to wake the rested applications, in this way you can greenify some applications without losing the capacity to get push message.
Consideration: Not all applications utilize GCM as push component, some applications make their own association for push in foundation benefit, along these lines can't profit by this fix and their push messages can never survive hibernation. Kindly DO NOT request that, it's only a "mission inconceivable" by and by. Rather, request that their engineer receive the more RAM-and-battery-accommodating GCM push.
Some applications may contain shrouded adjust assignments which runs intermittently, however can't be crippled by client in framework Settings – Account – Sync. This component uncovers those concealed match up undertakings and let you to debilitate them.
2. Introduce the "Structure" in the "Xposed Installer" and actuate "Greenify" in "Modules".
Since these test includes all need OS level patches, generally they must be connected with ROM modding, which is exceptionally gadget particular and ROM-selective. Xposed system is another want to do better grained small fixes in a ROM-free manner. On account of Xposed structure, you can appreciate these test highlights of Greenify without supplanting your ROM.
How to Use it Greenify Donate v3.9.9.1 build 39910 Full APK ?
1) Remove any past adaptation of Greenify and Donation Package first!!!
3) Open Xposed Installer, select greenify inside modules tab, open structure tab at that point press introduce/refresh and reboot.
0 Response to "Greenify Donate v3.9.9.1 build 39910 Full APK"