'br}
'br}
{\
config_data - Query or change configuration of Perl modules
# Get config/feature values config_data --module Foo::Bar --feature bazzable config_data --module Foo::Bar --config magic_number
# Set config/feature values config_data --module Foo::Bar --set_feature bazzable=1 config_data --module Foo::Bar --set_config magic_number=42
# Print a usage message config_data --help
The f(CW*(C`config_data*(C' tool provides a command-line interface to the configuration of Perl modules. By *(L"configuration*(R", we mean something akin to *(L"user preferences*(R" or *(L"local settings*(R". This is a formalization and abstraction of the systems that people like Andreas Koenig (f(CW*(C`CPAN::Config*(C'), Jon Swartz (f(CW*(C`HTML::Mason::Config*(C'), Andy Wardley (f(CW*(C`Template::Config*(C'), and Larry Wall (perl's own Config.pm) have developed independently.
The configuration system employed here was developed in the context of f(CW*(C`Module::Build*(C'. Under this system, configuration information for a module f(CW*(C`Foo*(C', for example, is stored in a module called f(CW*(C`Foo::ConfigData*(C') (I would have called it f(CW*(C`Foo::Config*(C', but that was taken by all those other systems mentioned in the previous paragraph...). These f(CW*(C`...::ConfigData*(C' modules contain the configuration data, as well as publicly accessible methods for querying and setting (yes, actually re-writing) the configuration data. The f(CW*(C`config_data*(C' script (whose docs you are currently reading) is merely a front-end for those methods. If you wish, you may create alternate front-ends.
The two types of data that may be stored are called f(CW*(C`config*(C' values and f(CW*(C`feature*(C' values. A f(CW*(C`config*(C' value may be any perl scalar, including references to complex data structures. It must, however, be serializable using f(CW*(C`Data::Dumper*(C'. A f(CW*(C`feature*(C' is a boolean (1 or 0) value.
This script functions as a basic getter/setter wrapper around the configuration of a single module. On the command line, specify which module's configuration you're interested in, and pass options to get or set f(CW*(C`config*(C' or f(CW*(C`feature*(C' values. The following options are supported:
Specifies the name of the module to configure (required).
When passed the name of a f(CW*(C`feature*(C', shows its value. The value will be 1 if the feature is enabled, 0 if the feature is not enabled, or empty if the feature is unknown. When no feature name is supplied, the names and values of all known features will be shown.
When passed the name of a f(CW*(C`config*(C' entry, shows its value. The value will be displayed using f(CW*(C`Data::Dumper*(C' (or similar) as perl code. When no config name is supplied, the names and values of all known config entries will be shown.
Sets the given f(CW*(C`feature*(C' to the given boolean value. Specify the value as either 1 or 0.
Sets the given f(CW*(C`config*(C' entry to the given value.
If the f(CW*(C`--eval*(C' option is used, the values in f(CW*(C`set_config*(C' will be evaluated as perl code before being stored. This allows moderately complicated data structures to be stored. For really complicated structures, you probably shouldn't use this command-line interface, just use the Perl s-1APIs0 instead.
Prints a help message, including a few examples, and exits.
Ken Williams<EMAIL_ADDRESS>Copyright (c) 1999, Ken Williams. All rights reserved.
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
Module::Build|(3), perl|(1).


Naseem Shah gets nod to make Pakistan Test debut against Australia at age of 16
by Australian Associated Press- Young quick backed to hold his own at the Gabba
- Pakistan confident of ending Australia domination
Pakistan captain Azhar Ali has no concerns about throwing 16-year-old Naseem Shah into the Test cauldron after confirming the quick will make his Test debut on Thursday against Australia in the series opener at the Gabba.
Naseem has played just seven first-class games but Ali, who has captained him for the bulk of those, says he’s shown he has the mental and physical strength to mix it with the best.
“Not many players can be at that standard so early but there are exceptions and he is one of them,” Ali said. “And hopefully, we are all looking forward to it, that ... he can have a very successful career.”
Ali admitted he was shocked when he initially witnessed Naseem’s raw talent. “When I saw him first, I was so surprised,” he said. “The control he had, the pace he had - and the temperament and the composure when he bowls is so much exciting to see.”
Naseem displayed his composure when he played the day after his mother’s death.
“Obviously, it was a hard time for him but he coped with it very nicely and he came out and bowled the very next day, which is very heartening,” Ali said. “He is opening up a little bit. Obviously, when he came in to first-class cricket, he was a bit shy but now he is starting to enjoy it.”
Ali said there was no reason to nurse the precocious quick through his Test debut. “The good thing about him is he is very fit ... I have no doubts in his fitness and his bowling skill,” Ali said.
Australia have not lost since 1988 at the Gabba but Ali says his side have the confidence, skill and fearlessness to end that streak.


Update: Many peoplea argue that messaging is flawed because your software breaks if you don't get a response. I wrote a new article, begging to differ.
I'm not going to link to the thread which set me off on this topic because there's no need to embarrass the people who say things like ...
Programming existed. Objects existed. Then [Alan] Kay contributed "-oriented" to the term "object-oriented programming" and the world went wild, but why?
Or another person, objecting to Kay's criticism of "modern" OO programming:
"It's different than what I already know so it's wrong." This kind of thinking is why I quit CS major, chose to not pursue a career in programming, and haven't looked back.
This was largely in response to Alan Kay's famous 1997 OOPSLA keynote which is worth watching in its entirety.
There's much more in that thread, and while some understood what Kay was trying to say, many others seemed unaware of Kay's background and acted as if he was some grumpy old dude who just graduated from a Rails Bootcamp.
This is Dr. Alan Kay we're talking about! He doesn't have random opinions about "objects", he invented the word back in the 60s . He saw what was happening in the programming world and was helping to craft many of these ideas, so he created a word to make these ideas easier to talk about.
And he's still bitter about choosing that word. It made people focus on the implementation rather than the behavior and it's all been downhill from there. Or as Dr. Kay put it "I invented the term Object-Oriented, and I can tell you I did not have C++ in mind."
Today, most developers think OOP is about classes and inheritance. Some of
the bright ones pipe up about encapsulation and polymorphism, but that's about
it. class Dog isa Mammal {...}
has won.
But for Dr. Kay, he states that OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. Why? Well, part of his background was cell biology and when he did the math on their computational power, he realized that while software routinely has trouble scaling, cells can easily coordinate and scale by a factor of over a trillion, creating some of the most fantastically complex things in existence, capable of correcting their own errors. By comparison, the most sophisticated computer software programs are slow, tiny, bugfests. Kay's conception of OOP starts with a single question: how can we get our software to match this scalability?
First, let's discuss isolation. This is a shorter term than "local retention and protection and hiding of state-process".
The interior of a cell is messy and confusing, but the cell membrance wraps this up in a tidy package, hiding the internal details.  But you don't. Could your software keep running if you had millions of exceptions being thrown every minute? I doubt it.
 Consider the following (awful) example:
class MyExample:
def reciprocal(self, num):
return 1.0/num
example = MyExample()
print example.reciprocal(4);
print example.reciprocal(0);
In the above code, we've encapsulated the reciprocal equation in the class, but then ...
0.25
Traceback (most recent call last):
File "class.py", line 7, in <module>
print example.reciprocal(0);
File "class.py", line 3, in reciprocal
return 1.0/num
ZeroDivisionError: float division by zero
The object dies, as does the code which contained it. This is the antithesis of what Dr. Kay is trying to get us to understand.
If you think of Web browsers and servers as objects, however, we see something closer to his vision. × Dr. Kay would likely take exception (ha!) to this because to a large extent, servers send out HTML, along with CSS and JavaScript and the browser needs to understand, not data and metadata, but a very limited structure. If your browser crashed every time a web server crashed or was otherwise unavailable, Microsoft IIS would never have reached 2.0.
Now that we sort of understand a core idea of Kay's, Lets take it further. Kay points out that from the early days of Arpanet in the 60s, to the time of his OOPSLA keynote in 1997, Arpanet had grown roughly 100 million times the size of what it was. × And in the early days of the Internet, no less! And it didn't have to be repeatedly taken down for maintenance every time we wanted to extend it. The internet, today, is sometimes cited by Kay as the only working example of his OO model. × For kids today: the Web is a small subset of the internet and is described by Kay as "a joke...done by amateurs"
Another key point is his arguing for extreme late-binding. What does that mean? Well, consider this code:
my $order = OrderFactory->fetch(%order_args);
my $invoice = $order->invoice;
If you have multiple "order" classes, you may not know which class you are
dealing with, so you can't know, at compile time which invoice
method you're calling. OOP languages generally don't select (bind) the method
(invoice
) for the invocant ($order
) until run time.
Otherwise, polymorphism can't work.
But what's extreme late binding? Does the invoice
method exist? In a language like Java, that code won't even compile if the
method doesn't exist. It might even be dead code that is never called, but you
can't compile it if that method isn't there. That's because Java at least
checks to ensure that the method exists and can be called.
For many dynamic languages, such as Perl (I ♥ Perl), there's no
compilation problem at all because we don't bind the method to the invocant
until that code is executed, but you might get a panicked 2AM call that your
batch process has failed ... because you might have encapsulation, but not
isolation. Oops.
×
Perl, like many other dynamic languages,
has features which allow the code for that method to be handled at runtime.
AUTOLOAD
magic can handle this case, but that is an article for
another day
. This is "extreme" late binding with virtually no checks
(other than syntax) performed until runtime.
Binding can also refer to binding a variable type to data.
×
This discussion conveniently ignores a large area of
comp-sci which asks why data and functions are different. Sue me.
. While
this is a grotesque oversimplification of a complex argument, one way of
looking at the difference between static and dynamic languages is that static
languages such as Java often bind the data type to the variable (in other
words, the named container of the data), meaning that you can never assign a
different type to that variable, while dynamic languages such as Perl bind the
data type to the data itself, meaning that the data knows about its type, but
the variable often does not.
×
You can bless
a
reference in Perl, so that the variable is aware of its type. This is how OO
is done in Perl.
The latter is late binding because you often
cannot infer, from static analysis, the data types at compile time.
×
Dynamic languages have static components and static
languages have dynamic components. The two are not mutually exclusive, but I
cannot possibly begin to cover that here.
Extreme late-binding is important because Kay argues that it permits you to not commit too early to the "one true way" of solving an issue (and thus makes it easier to change those decisions), but can also allow you to build systems that you can change while they are still running! When was the last time you changed the behavior of a program and didn't have to stop it and restart it, often waiting hours for a complex recompilation?
We can kind of see the isolation and late-binding, but it's messaging where Kay's message seems to fall down for most, even though he's quite insistent that it's the most important thing there is in OOP. In essence, objects should be able to announce that they did things and other objects can ignore them or say "hey, that's cool. Here's what I did in response."
But that doesn't really get to the core concept of messaging and frankly, this is the one area where I think Kay has been a touch vague, largely because many developers think that ideas are nice, but they want to see an implementation or proof of concept. In Kay's world. every object is almost like an entire computer, not just a unique area of responsibility, and each object can receive messages and figure out whether or not it knows how to deal with them.
In other words, you don't execute code by calling it by name: you send some data (a message) to an object and it figures out which code, if any, to execute in response. In fact, this can improve your isolation because the receiver is free to ignore any messages it doesn't understand. It's a paradigm most are not familiar with, but it's powerful.
There's a lot more to be said about this, but I'll stop and instead direct you to this article, written by Alan Kay, about The Early History of Smalltalk . I actually found myself giddy reading that, getting a glimpse into the Cambrian explosion of computing ideas which happened during the 60s and 70s. Sadly, computing, as with evolution, left that explosive era with powerful tools, but fewer ideas. Functional programming is slowly gaining more converts, logic programming is largely ignored × I enjoyed Prolog so much that I wrote a Prolog interpreter in Perl. I also started a continuation-based logic programming system, but never got around to finishing it. , but most programming today is procedural or class-based OOP. But Kay's ideas of what he intended for OOP are still with us. You can check out Erlang and discover a marvelous programming language where code is isolated, late-binding, and passes messages around. And what do you get for that?
That last point is a killer feature for many companies. The Erlang syntax and behavior is strange for many developers (it looks a lot like Prolog with the solver removed), if you have millions of customers counting on your service to always be there, Erlang is a powerful option.
Kay argues (correctly, IMHO), that the computer revolution hasn't happened
yet because while our bodies are massively scalable meat computers, our
silicon computers generally don't scale in the slightest. This isn't just
because silicon is slow; it's because of things like print
customers.fetch(customer_id).last_name
not actually having a
last_name
method, throwing an exception (assuming it compiled in
the first place) and programmers getting frantic late-night calls to bring the
batch system back up. The only real upside is that it offers job security.
Sadly, this is where most of us are today. And would-be programmers get
silly lectures telling them that class Motorcycle extends
Vehicle
, the instructor (isa Person
) gets flustered
explaining for the nth time the difference between a class and an
instance, while a student (isa Person
) in the back is noticing
that a bicycle looks an awful lot like a motorcycle and the code she's looking
at doesn't seem to account for this.
So class-based OO has won, × Er ... except for the prototype-based OO in Javascript, though if you squint, it looks an awful lot like single inheritance. even with its limitations, arguments over inheritance versus composition, static versus dynamic typing, × There is a delightful irony of class-based OO fans who sneer at dynamic typing, but let's not go there. and programmers arguing whether "objects" are data with behaviors attached or vice versa. So this sometimes puts me in an awkward situation when someone asks me what objects are since the myriad disagreements are strong, and valid.
I sort of punt on this, taking a "meta view" of what we're trying to accomplish when we write software. So I'll finish up by offering my view on objects, with an extended quote from my book Beginning Perl .
ÆVAR THE PERSONAL SHOPPER
Many books have been written about OOP and even among experts, there is often disagreement about what OOP is. Many programmers have tried to explain OOP and leave the programmer confused. A case in point is the classic “An object is a data structure with behaviors attached to it.” Although that’s correct, that’s also an awful description and tells you almost nothing you need to know, so instead of giving you a textbook definition, we’re going to tell you a story.
You’re an awfully busy person and have little free time but plenty of disposable income, so you’ve decided to hire a personal shopper. His name is Ævar (any resemblance to reviewers of this book, living or dead, is purely coincidental) and he’s friendly, flamboyant, and most of all, cheap.
Because Ævar is new to both your city and the job, you have to tell him carefully how much money he can spend, exactly what quality of products you want, and where to buy them. You may even have to tell him which route to drive to pick up the goods and how to invoice you.
That, in essence, is procedural code and that’s what you’ve been doing up to now. You’ve been carefully telling the computer every step of the way what to do.
 And he does. He knows what you like and where to get it. He’s become an expert. In OO terms, you might now be doing this:
my $aevar = Shopper::Personal->new({ name => 'Ævar', budget => 100 }); $aevar->buy(@list_of_things_to_buy); my $invoice = $aevar->get_invoice;
You’re no longer telling Ævar every little step he needs to take to get your shopping done. He’s an expert, and he has all the knowledge needed to do your shopping for you and present you with the bill.
And that's it. Objects are simply experts. You tell them what you need and they get it done. Forget all of the handwaving about blueprints or "data with behaviors." Those are implementation details. And once you start thinking about objects as simply experts about a particular problem domain, OOP becomes much easier.
Please leave a comment below!
If you'd like top-notch consulting or training, email me and let's discuss how I can help you. Read my hire me page to learn more about my background.
Copyright © 2018-2020 by Curtis “Ovid” Poe.


I’m passionate about great experiences, both in software and in physical spaces. I share this love with my clients by facilitating workshops that help companies develop optimal user interactions, build products with purpose and create meaningful business strategies.
I work hard to collect research, insights and perspective in proven, systematic and interactive ways from both employees and customers. I’m passionate about learning, listening, and understanding people to get to the heart of a real issue and work together to create something better.
I’ve worked with start-ups, non-profits, and Fortune 100 companies to create shared understanding, new products and features, business processes and solved problems.
I’m also a Scrum Certified Product Owner (SCPO) and I love working with product teams on building and shipping the right things for their users.
Drop me a line and let’s talk.


Table of Contents
What's This About?
Nadia Eghbal's acclaimed book, Working in Public, introduces a novel way of classifying different types of open source projects. By examining the rate of user growth and contributor growth for any given project, Nadia arrives at four different classifications: toys, clubs, stadiums, and federations.
The graphic below from Working in Public (used with permission from Nadia) provides a quick overview of the differences between these classifications, but more specific information about each classification is further below.
Toys
Like the name suggests, toys are small projects with low (or no) contributor growth and low (or no) user growth. This includes the one-off projects you put on GitHub and never expect anyone else to use (like this code from a JS fractal tutorial). Esoteric programming languages like Piet likely also fit in this category.
Clubs
As the name suggests, clubs are cozy collaborations of passionate participants. Nadia characterizes them as projects with low user growth and high contributor growth. Generally, clubs cater to more niche interests, such as those of a specific scientific community (e.g. the astronomers and astrophysicists using astropy).
Club-style projects are described as follows in the book:
Clubs are similar to meetup or hobby groups: they attract a narrow group of users, who then also become contributors because they have higher context for the project’s activity and feel a sense of affinity to the group. Clubs may not have a wide reach, but they’re loved and built by a group of enthusiasts.
Stadiums
Stadiums are projects defined by high user growth and low contributor growth. In the same way that lots of people at a concert focus on one or a few performers on the main stage, the fast-growing userbase of a stadium-style project depends on one or a few maintainers.
Due to their low contributor growth, the social structure of these projects tends to be more centralized (one-to-many interactions), so the primary bottleneck to getting work done (merging PRs, responding to issues, etc.) is maintainer attention.
Babel and Bootstrap are two examples of stadium-style projects.
Federations
Federations are projects defined by high user and contributor growth, and are relatively rare. Nadia describes these as what we "typically think of when we imagine an open source project". Examples of federations include the Rust programming language and the Linux project.
The large amount of contributor and user growth means that projects of this type generally take on a decentralized (many-to-many interactions) social and organizational structure. As described in the book:
[Federations are] more complex to manage from a governance standpoint, so they tend to develop processes -- voting, leadership positions, foundations, working groups, and technical councils -- that address coordination issues within their contributor community. These contributors, in turn, make decisions for a broader constituency of passive users.
Using the Badges
Based on the descriptions above, you can add a badge that feels appropriate for the current or desired style of your project using the code snippets below. With your project's README.md
open for editing, add any of the following near the top of the file:
Toy

This will render a badge that looks like this:
Club

This will render a badge that looks like this:
Stadium

This will render a badge that looks like this:
Federation


Saved To Notebook
|
Notebook
Save Snapshot to Notebook
Download
{% if share != True %}
Share
{% endif %}
×
Share
With link sharing on, anyone with this link will be able to view this dataset.
Link sharing is off


{% extends '_layouts/layout_2-3_no_title_block.html' %} {% block page_title %} Where would you like to find help? {% endblock %} {% block pageTitle %} Where would you like to find help? {% endblock %} {% block pageIntro %} {% endblock %} {% block content %}


workbox.rangeRequests. Plugin
class static
Version
v3.0.0
The range request plugin makes it easy for a request with a 'Range' header to be fulfilled by a cached response.
It does this by intercepting the cachedResponseWillBeUsed
plugin callback and returning the appropriate subset of the cached response body.
Constructor
Plugin
new Plugin()


Install Directories
- Libraries will be installed in
/usr/local/lib
- Headers will be installed in
/usr/local/include
- Examples, documentation and CMake config files will be installed in
/usr/local/share
For complete list of updates, visit ArrayFire Release Notes


PG_DEFAULT_ACL
Stores information about default access privileges. For more information on default access privileges, see ALTER DEFAULT PRIVILEGES.
PG_DEFAULT_ACL is visible to all users. Superusers can see all rows; regular users can see only their own data. For more information, see Visibility of Data in System Tables and Views.
Table Columns
| Column Name | Data Type | Description |
|---|---|---|
| defacluser | integer | ID of the user to which the listed privileges are applied. |
| defaclnamespace | oid | The object ID of the schema where default privileges are applied. The default value is 0 if no schema is specified. |
| defaclobjtype | character |
The type of object to which default privileges are applied. Valid values are as follows:
|
| defaclacl | aclitem[] |
A string that defines the default privileges for the specified user or user group and object type. If the privileges are granted to a user, the string is in the following form:
username The name of the user to which privileges are granted. If username is omitted, the privileges are granted to PUBLIC. If the privileges are granted to a user group, the string is in the following form:
privilegestring A string that specifies which privileges are granted. Valid values are:
grantor The name of the user that granted the privileges. The following example indicates that the user
|
Example
The following query returns all default privileges defined for the database.
select pg_get_userbyid(d.defacluser) as user, n.nspname as schema, case d.defaclobjtype when 'r' then 'tables' when 'f' then 'functions' end as object_type, array_to_string(d.defaclacl, ' + ') as default_privileges from pg_catalog.pg_default_acl d left join pg_catalog.pg_namespace n on n.oid = d.defaclnamespace; user | schema | object_type | default_privileges -------+--------+-------------+------------------------------------------------------- admin | tickit | tables | user1=r/admin + "group group1=a/admin" + user2=w/admin
The result in the preceding example shows that for all new tables created by user
admin
in the tickit
schema, admin
grants
SELECT privileges to user1
, INSERT privileges to group1
,
and UPDATE privileges to user2
.


Figure 2: Percentage of VAT and/or PAYE based enterprises by year, 2009 to 2014
Source:Inter Departmental Business Register (IDBR), Office for National Statistics


Gecode::Int::Branch::ValRnd< _View > Class Template Reference
[Integer value selection for brancher]
Class for random value selection. More...
#include <branch.hh>
Public Types | |
| typedef _View | View |
| View type. | |
| typedef int | Val |
| Value type. | |
| typedef ArchivedRandomGenerator | Choice |
| Choice type. | |
Public Member Functions | |
| ValRnd (void) | |
| Default constructor. | |
| ValRnd (Space &home, const ValBranchOptions &vbo) | |
| Constructor for initialization. | |
| int | val (Space &home, _View x) |
| Return minimum value of view x. | |
| ModEvent | tell (Space &home, unsigned int a, _View x, int n) |
| Tell (a = 0) or (a = 1). | |
| Choice | choice (Space &home) |
| Return choice. | |
| Choice | choice (const Space &home, Archive &e) |
| Return choice. | |
| void | commit (Space &home, const Choice &c, unsigned a) |
| Commit to choice. | |
| void | update (Space &home, bool share, ValRnd &vs) |
| Updating during cloning. | |
| void | dispose (Space &home) |
| Delete value selection. | |
Static Public Attributes | |
| static const unsigned int | alternatives = 2 |
| Number of alternatives. | |
Protected Attributes | |
| ArchivedRandomGenerator | r |
| The random number generator. |
Detailed Description
template<class _View>
class Gecode::Int::Branch::ValRnd< _View >
Class for random value selection.
Requires
#include <gecode/int/branch.hh>
Definition at line 103 of file branch.hh.
Member Typedef Documentation
| typedef _View Gecode::Int::Branch::ValRnd< _View >::View |
| typedef int Gecode::Int::Branch::ValRnd< _View >::Val |
| typedef ArchivedRandomGenerator Gecode::Int::Branch::ValRnd< _View >::Choice |
Constructor & Destructor Documentation
| Gecode::Int::Branch::ValRnd< View >::ValRnd | ( | void | ) | [inline] |
Default constructor.
Definition at line 79 of file select-val.hpp.
| Gecode::Int::Branch::ValRnd< View >::ValRnd | ( | Space & | home, | |
| const ValBranchOptions & | vbo | |||
| ) | [inline] |
Constructor for initialization.
Definition at line 82 of file select-val.hpp.
Member Function Documentation
| int Gecode::Int::Branch::ValRnd< View >::val | ( | Space & | home, | |
| View | x | |||
| ) | [inline] |
Return minimum value of view x.
Definition at line 86 of file select-val.hpp.
| ModEvent Gecode::Int::Branch::ValRnd< View >::tell | ( | Space & | home, | |
| unsigned int | a, | |||
| View | x, | |||
| int | n | |||
| ) | [inline] |
Tell (a = 0) or (a = 1).
Definition at line 98 of file select-val.hpp.
| ValRnd< View >::Choice Gecode::Int::Branch::ValRnd< View >::choice | ( | Space & | home | ) | [inline] |
Return choice.
Definition at line 103 of file select-val.hpp.
| ValRnd< View >::Choice Gecode::Int::Branch::ValRnd< View >::choice | ( | const Space & | home, | |
| Archive & | e | |||
| ) | [inline] |
Return choice.
Definition at line 108 of file select-val.hpp.
| void Gecode::Int::Branch::ValRnd< View >::commit | ( | Space & | home, | |
| const Choice & | c, | |||
| unsigned | a | |||
| ) | [inline] |
Commit to choice.
Definition at line 113 of file select-val.hpp.
| void Gecode::Int::Branch::ValRnd< View >::update | ( | Space & | home, | |
| bool | share, | |||
| ValRnd< _View > & | vs | |||
| ) | [inline] |
Updating during cloning.
Definition at line 118 of file select-val.hpp.
| void Gecode::Int::Branch::ValRnd< View >::dispose | ( | Space & | home | ) | [inline] |
Delete value selection.
Definition at line 123 of file select-val.hpp.
Member Data Documentation
ArchivedRandomGenerator Gecode::Int::Branch::ValRnd< _View >::r [protected] |
const unsigned int Gecode::Int::Branch::ValRnd< _View >::alternatives = 2 [static] |
Number of alternatives.
Reimplemented in Gecode::Int::Branch::AssignValRnd< View >.
The documentation for this class was generated from the following files:
- gecode/int/branch.hh (Revision: 12001)
- gecode/int/branch/select-val.hpp (Revision: 12001)


#include <rpc/auth_des.h> int rtime(struct sockaddr_in *addrp, struct rpc_timeval *timep, struct rpc_timeval *timeout);
The Time Server Protocol gives the time in seconds since 00:00:00 UTC, 1 Jan 1900, and this function subtracts the appropriate constant in order to convert the result to seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
When timeout is non-NULL, the udp/time socket (port 37) is used. Otherwise, the tcp/time socket (port 37) is used.
Some in.timed versions support only TCP. Try the example program with use_tcp set to 1.
Libc5 uses the prototype
int rtime(struct sockaddr_in *, struct timeval *, struct timeval *);and requires <sys/time.h> instead of <rpc/auth_des.h>.
The program connects to a computer called "linux". Using "localhost" does not work. The result is the localtime of the computer "linux".
#include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> #include <time.h> #include <rpc/auth_des.h> #include <netdb.h> static int use_tcp = 0; static char *servername = "linux"; int main(void) { struct sockaddr_in name; struct rpc_timeval time1 = {0,0}; struct rpc_timeval timeout = {1,0}; struct hostent *hent; int ret; memset(&name, 0, sizeof(name)); sethostent(1); hent = gethostbyname(servername); memcpy(&name.sin_addr, hent->h_addr, hent->h_length); ret = rtime(&name, &time1, use_tcp ? NULL : &timeout); if (ret < 0) perror("rtime error"); else { time_t t = time1.tv_sec; printf("%s\n", ctime(&t)); } exit(EXIT_SUCCESS); }


Provide classes and interfaces for reporting service,
TestReporter
and
ExtendTestReporter
are interfaces that can be implemented by new reporters,
Reporter
is the interface that present the service used by the tests and system objects.


Stored User IDs
Example Certificate
Certificate Generator
My
email address
is
and
I want to generate a certificate
with message,
Generate


Jorge Luis Dupre Lachazo, 21, has been charged with first-degree murder in the August death of 75-year-old Evelyn Smith Udell. Palm Beach County court records show the local State Attorney’s office filed a notice of intent to seek the death penalty Monday.
When police arrived at Udell's Boca Raton home, they found David Gonzalez, Lachazo’s coworker. Gonzalez said he and Lachazo worked for JB Home Delivery, a subcontractor of Best Buy, and had delivered a washer and dryer to Udall.
Gonzalez told police he went outside to make a phone call after he and Lachazo had installed the appliances while his colleague stayed inside to talk to Udall about her new appliances.
FLORIDA SHERIFF CALLS WOMAN'S DOMESTIC ABUSE MURDER WORST HE'S EVER SEEN, CALLS FOR LAWS TO CHANGE
Gonzalez said that after he heard screams from inside the home, he went back inside and saw blood and Udall lying on the floor. While Gonzalez was calling 911, Lachazo got into their truck and drove away.
A responding officer saw the truck and pulled over Lachazo. Investigators said Lachazo admitted he hit the woman with a mallet and doused her with a chemical that spontaneously combusted.
Authorities have not reported any potential motive for the killing.
The Associated Press contributed to this report.


|
My girlfriend and I had an emotional conflict over something I said to her. She said she was hurt by my words, and I defended myself by saying it was just the truth. It was about something inconsequential, so inconsequential that I do not remember the reason for it now, but at the time I remember feeling compelled to say what I said to her. The source of the conflict was some deep-rooted feelings I had towards her that emerged when I noticed she would do/say the same things that in my view made her a hypocrite. I handled it pretty poorly by accusing her of something much more serious than I intended to, and in turn it hurt her very deeply. It took awhile for me to realize what I had said and done, but at that time it was already too late. You cannot un-say words to someone else. What I did definitely made the conflict worse. If I could go back, I would definitely have taken back what I said, and maybe initiated the conversation about my feelings in a less accusatory manner. I learned that words can be severely hurtful to people, and to speak carefully at all times. |


[gecode-users] CMake config improvements
victor.zverovich at gmail.com
victor.zverovich at gmail.com
Wed Sep 3 17:47:55 CEST 2014
Thanks, Christian. Good timing =)
Cheers,
Victor
On Wed, Sep 3, 2014 at 1:44 AM, Christian Schulte <cschulte at kth.se> wrote:
> Hi Victor,
>
>
>
> Thanks. I will smuggle this into 4.3.0 as I have to rebuild the
> sourcepackages anyway (there are syntax errors in the changelog). It should
> be up in two hours or so.
>
>
>
> Cheers
>
> Christian
>
>
>
> --
>
> Christian Schulte, Professor of Computer Science, KTH,
> www.gecode.org/~schulte/
>
>
>
> *From:* users-bounces at gecode.org [mailto:users-bounces at gecode.org] *On
> Behalf Of *victor.zverovich at gmail.com
> *Sent:* Tuesday, September 02, 2014 8:57 PM
> *To:* users at gecode.org
> *Subject:* [gecode-users] CMake config improvements
>
>
>
> Hello,
>
>
>
> Please find attached a patch which implements the following changes to the
> CMake build configuration:
>
>
>
> * Set the output directory for runtime target files (executables and DLLs)
> to bin/ subdirectory of the project's binary directory to avoid collisions
> when Gecode is used as a subproject.
>
>
>
> * Improve suppression of warnings.
>
>
>
> * Add GECODE_USE_QT variable which specifies whether to use Qt. Qt is used
> if GECODE_USE_QT is TRUE or unset.
>
>
>
> * Prevent linker warnings on MSVC.
>
>
>
> * Use per-target instead of global include directories. This simplifies
> use of Gecode as a subproject because add_target_libraries(<target>
> <gecode-lib>) now sets the necessary include directories for <target> in
> addition to link dependencies.
>
>
>
> * Fix by Tony Kelman to fully link internal dependencies needed for
> creating DLLs: https://github.com/ampl/gecode/pull/2
>
>
>
> Best regards,
>
> Victor
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20140903/08c8e679/attachment.html>
More information about the users
mailing list


Want to play? The instructions are simple:
- Choose any U.S. President (past or present)
- The computer will ask 5 questions
- Then try to guess your pick
- If the computer guesses incorrectly, you win!
- Otherwise, you owe me $5 dollars.
Note! The computer considers middle names.
Ready to begin?


A Super Gluu push notification has been sent to your registered device. Approve the push to login.
Didn't receive the push notification?
Gluu, Inc, | Use subject to MIT LICENSE


I have undertaken several design & development projects in the past several years. Projects presented here are the ones not binded to non-disclosure agreements.
A wordpress blog theme from the year 2008:
From the year 2007:


Discover the person behind the politics! Find out what makes your MP tick.
MP for Hackney South & Shoreditch.
Loves a fancy food market.
Hates Valentine's Day.
MP for East Ham.
Loves long walks on the beach.
Hates dress down Friday.
MP for Hendon.
Loves talking about single-use plastic.
Hates Jeremy Bentham.
MP for Birmingham Yardley.
Loves to watch Love Island.
Hates celebrating International Men's Day.
MP for Doncaster North.
Loves a bacon sandwich.
Hates table manners.
MP for Broxtowe.
Loves a gin in the Commons Bar.
Hates the Conservative Party.
MP for Paisley and Renfrewshire South.
Loves being the youngest person in Parliament.
Hates haggis.
MP for Uxbridge.
Loves the sound of his own voice.
Hates brushing his hair.


For each subscription, a charge can be defined that a customer has to pay on a recurring basis. Monthly, weekly, daily, or hourly periods are supported. The recurring charge for a subscription is independent of the amount of users, events, or other usage data.
A customer subscribes to a service on Monday, 12 o'clock p.m. The subscription ends on Thursday, 12 o'clock p.m.
The price model specifies a recurring charge per subscription of 100.00 € per DAY.
The recurring charge for the subscription is calculated as follows:
With pro rata calculation, the customer is charged with 300 €. With per time unit calculation, the costs are 400 € because each day is fully charged.


HTML span Examples
Inline Styling with spans
Use the span tag to color part of the text red
Use the span tag to change the font-size part of the text
Nesting of spans
This is a test of nesting span elements.
Presentational Misuse of spans (requires .italic CSS class to be defined)
I am italic


MENU
OUR PIZZA VARIETY
CHEESE PIZZA
VEGGGIE PIZZA
PEPPERONI
MEAT PIZZA
MARGHERITA PIZZA
BBQ chicken pizza
Order Details


Tensile strength \(R_m\): maximal stress that a material can withstand before breaking
Total elongation \(A_t\): total elongation at break


Gallery of an Insane Artist Artwork Portfolio Drawings Akira Shinonome, 2018 Sculptures Ghost Rider - Akira Shinonome, 2018 Photograph Dutch's Cat, 2018


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 6-8
Dietary
This is an elegant version of a very rustic Charlotte that my mum makes. It is lighter than the classic recipe – much lower in butter – and it has a wonderful texture and very clean, clear flavours. You will notice that I have used two varieties of apple – the Cox’s Orange Pippin has acidity and is wonderfully firm, while the Blenheim Orange begs to be puréed. The combination is what creates the magic. Bon appétit!
For the caramelised apples, in a large sauté pan or frying pan over a medium–high heat, heat the sugar to a dark golden-brown caramel without stirring, then add the butter. The caramel will emulsify with the butter and the cold butter will also stop the cooking of the caramel. Add the apples and cook in the caramel for 5 minutes, with a lid on, until they soften but still hold their shape (the centre will still be a little raw). Remove from the heat.
For the compôte, mix 50ml/2fl oz of the apple juice with the sugar and pectin. Slide the chopped apple into a medium saucepan set over a medium heat. Add the remaining apple juice and cook for 10 minutes, covered with a lid, until the apples break down. Add the sugar/pectin mix and vanilla purée or extract, stir and cook for a further 5 minutes to allow any moisture to evaporate. Remove from the heat.
Preheat the oven to 210C/190C Fan/Gas 6½.
To prepare the cake ring, lightly butter the inside of a 15x6cm/6x2½in cake ring. Dip the ring in sugar so that the sugar coats the inside of the ring. Tap it lightly to ensure an even coating; tap off any excess. Lay out a 25cm/10in square of aluminium foil, then cover it with the same size of parchment paper. Place the cake ring on top and roll up the foil and paper, so the foil holds tightly to the bottom of the ring – this will prevent any juices escaping. Place the ring on a baking tray.
For the Charlotte, cut the slices of bread into 6cm/2½in squares. Lightly spread both sides of the bread with the butter and fry in a large frying pan over a medium–high heat for 20–30 seconds on one side, until evenly golden-brown. Transfer the bread to a plate or tray then use it to line the inside of the ring, browned sides facing outwards and overlapping by 2cm/¾in. Press to ensure they stick to the sides.
To build, mix the caramelised apple into the compôte, then pour the mixture into the centre of the ring to fill the Charlotte. It will look too much and there will be a slight dome, but after cooking the apples will collapse under their own weight until they are level with the rim of the ring. Place the apple Charlotte in the oven for 30 minutes. Remove from the oven and leave to cool completely for a minimum of 3 hours. This will allow the pectin to set fully and firm up, which will also make the Charlotte easier to slice. Once cool, turn the Charlotte upside down by placing a large plate on top and flipping it over. Remove the foil and paper from the ring. You will need to heat the ring a little to lift it off smoothly; either use a blowtorch or place in an oven heated to 180C/160C Fan/Gas 4 for a minute, then ease it off gently.
To serve, carefully cut the Charlotte into 6–8 pieces. This beautiful dessert can be served with vanilla ice cream or crème Chantilly. It’s also perfect with a glass of your best cider.


Welcome to the MSAL.js v2 Angular Quickstart!
This sample demonstrates how to configure MSAL Angular to login, logout, protect a route, and acquire an access token for a protected resource such as the Microsoft Graph.
Please sign-in to see your profile information.
Login successful!
Request your profile information by clicking Profile above.


DONE
Indian Government All Scheme Portal | Here you can register to those schemes,which are suitable for you.


OrdinalCategoricalEncoder¶
-
class
categorical_encoders.
OrdinalCategoricalEncoder
(encoding_method='ordered', variables=None)[source]¶ Replaces categories by ordinal numbers (0, 1, 2, 3, etc). The numbers can be ordered based on the mean of the target per category, or assigned arbitrarily.
For the ordered ordinal encoding for example, in the variable colour, if the mean of the target for blue, red and grey is 0.5, 0.8 and 0.1 respectively, blue is replaced by 1, red by 2 and grey by 0.
For the arbitrary ordinal encoding the numbers will be assigned arbitrarily to the categories.
The Encoder will encode only categorical variables (type ‘object’). A list of variables can be passed as an argument. If no variables are passed as argument, the encoder will only encode categorical variables (object type) and ignore the rest.
The encoder first maps the categories to the numbers for each variable (fit). The transformer replaces the categories by numbers (transform).
Parameters: - encoding_method (str, default='ordered') – Desired method of encoding. ‘ordered’: the categories are numbered in ascending order according to the target mean per category. ‘arbitrary’ : categories are numbered arbitrarily.
- variables (list) – The list of categorical variables that will be encoded. If none, it defaults to all object type variables.
-
encoder_dict_
¶ dictionary – The dictionary containing the ordinal number: category pairs used to replace categories for every variable
-
fit
(X, y=None)[source]¶ Learns the numbers that should be used to replace the labels in each variable.
Parameters: - X (pandas dataframe of shape = [n_samples, n_features]) – The training input samples. Should be the entire dataframe, not just seleted variables.
- y (Target. Can be None if selecting encoding_method = 'arbitrary') –


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Gemini Performance Solutions Inc.
Mailing Address:
200 - 683 - 10 St SWCALGARY, Alberta
T2P 5G3
Location Address:
200 - 683 - 10 St SWCALGARY, Alberta
T2P 5G3
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Company Profile
NATURE OF BUSINESS:
Gemini Learning Systems Inc. (Gemini) has developed a technology-
based training tool called SWIFT (SoftWare Intelligent Freeform
Training). The company continues to develop new features and
enhancements to SWIFT for distance delivery and improved pedagogy
through research and development projects, both independently and
in joint venture partnerships. Gemini also provides expertise in
UNIX and Open Systems for instructor-led training, courseware
development, consulting and system administration outsourcing
services.
COMPANY BACKGROUND AND HISTORY:
Gemini was established to provide UNIX and Open Systems
expertise for instructor-led, courseware development, consulting,
and system administration services. Gemini offers introductory
to advanced training courses for UNIX, SUN, AIX, NextStep, C,
C++, Motif, Oracle, and object-oriented programming.
In 1991, the company began investing in the development of a
unique software training tool, SWIFT (SoftWare Intelligent
Freeform Training) to complement existing services and expand
business opportunities. A prototype was completed in 1992, which
allowed the company to test the product and conduct extensive
market research into the global market potential. In 1993, Gemini
and the Alberta Research Council entered into two consecutive
Joint Research Ventures totalling $ 1.5 million, not including
commercialization costs. SWIFT was launched internationally in
1994.
CANARIE Member
Full profile
Full profile
Contact information
Company description
Product / Service / Licensing
technology-based training tool. SWIFT is a sophisticated adaptive
learning environment into which virtually any course content
(text, graphics, video, sound, animation and simulations) can be
easily inserted. The learning environment is already created in
SWIFT, therefore no programming skills are required. Preparing
courses for insertion into SWIFT takes an average of 2-8 hours of
preparation for every 1 hour of instruction.
Gemini actively participates in research joint ventures nationally
and internationally, dedicating significant resources to research
and development in applying artificial intelligence techniques
to training, implementing progressive learning methods and
staying cognizant of the latest developments and trends in Open
Systems. The company is currently undertaking research to
determine the effectiveness of the SWIFT interface for secondary
and post-secondary audiences. Gemini entered into an
international joint research venture to provide an ISDN link and
extension toolkit for SWIFT for distance learning. This is one
of only three private company proposals chosen for the Canada-EC
agreement for Scientific and Technological Cooperation. Partners
include Condat from Berlin, Germany, the European Association for
Distance Teaching Universities (EADTU) of De Heerlen, The
Netherlands and CITI of Laval, Quebec. Gemini has also been
invited to participate in three centres of excellence proposals:
Telelearning, led by Simon Fraser University; Technology Based
Learning, led by the University of Calgary and McMaster University
and Telemedicine, led by the University of Calgary Faculty of
Medicine.
which provides an entirely new approach to the development of
interactive CBT. SWIFT is the only CBT development tool in the
world that porvides an Adaptive Learning Environment, adaptive
testing, and implements SGML (Standard Generalized Markup
Language) an ISO standard.
ConnectIT Category Description: TRAINING Authoring Tools
ConnectIT-keywords: CBT, SGML, Adaptive Learning Environment,
Adaptive Testing, Distance Education
(simplified and tradional) is apporximately 12 hours of fully
interactive, comprehensive training and exercises. SWIFT will
test your knowledge first and then adapt the course specifically
to your needs or allow you to surf directly to any topic for easy
review.
ConnectIT Category Description: Educational Softwares
Computing
ConnectIT-keywords: CBT, Internet training, SGML, Adaptive
Learning Environment, Adaptive Testing, Distance Education
approximately 14 hours of fully interactive, comprehensive
training andexercises. SWIFT will test your knowledge first and
then adapt the course specifically to your needs or allow you to
surf directly to any topic for easy review.
ConnectIT Category Description: Educational Softwares
Computing
ConnectIT-keywords: CBT, SGML, HTML training, Adaptive Learning
Environment, Adaptive Testing, Distance Education
Market profile
Alliances:
Strategic alliances:
STRATEGIC RELATIONSHIPS:Alberta Research Council - SWIFT has been developed in two joint
research projects with the Alberta Research Council.
Foothills School Division - partnered with Gemini to implement
SWIFT for the purposes of conducting usability studies in a
secondary education environment and provide feedback from
students
and teachers for continued development.
Kenonics Controls Inc. - a Course-Added-Reseller for SWIFT, are
developing a gas measurement course for a client and plan to
distribute the end-user SWIFT course worldwide.
Oracle Corporation - Gemini is a Service Provider for the
delivery of end-user training.
University of Calgary - several professors from the University,
representing different faculties, beta test new releases of
SWIFT and sit on the SWIFT Steering Committee.
GEOGRAPHIC MARKET ACTIVITIES AND INTERESTS:
Gemini is seeking Reseller partners and SWIFT Distributors
worldwide
Value-Added Partners - enhance existing services by implementing
SWIFT as a Total Solution Provider, providing a cost-effective
technology-based training solution to clients or as a Course
Added or Value-Added partner, developing course content for
implementation into SWIFT.
SWIFT Distributors - market the SWIFT (Producer's Kit) or the
expanding library of SWIFT end-user courses, including
WordPerfect
for Windows and Microsoft Word for Windows. Course library
distributors include retail chains, wholesalers or training firms
with an infrastructure in place to manage higher volumes of
product with minimal requirement for product expertise and
support.
SWIFT (Producer's Kit) Distributors will work closely with
Gemini.
An excellent business reputation and compatibility with the
business interests and attitudes of Gemini is essential as is an
established client-base and experienced team of dedicated sales
professionals.
Geographic markets:
Export experience:
- Netherlands
- United Kingdom
- United States
- California
- Massachusetts
- Texas
Actively pursuing:
- Afghanistan
- Albania
- Algeria
- Armenia
- Australia
- Austria
- Azerbaijan
- Bangladesh
- Belarus
- Belgium
- Bhutan
- Brazil
- Brunei Darussalam
- Bulgaria
- Cambodia
- China
- Czech Republic
- Denmark
- Estonia
- Finland
- France
- Georgia
- Germany
- Gibraltar
- Greece
- Hong Kong
- Hungary
- Iceland
- India
- Indonesia
- Ireland
- Italy
- Japan
- Kazakhstan
- Korea, Democratic People's Republic of
- Korea, Republic of
- Kyrgyzstan
- Lao People's Democratic Republic
- Latvia
- Lithuania
- Luxembourg
- Macao
- Malaysia
- Malta
- Mexico
- Moldova, Republic of
- Mongolia
- Montenegro
- Nepal
- Norway
- Pakistan
- Philippines
- Poland
- Portugal
- Romania
- Russian Federation
- Serbia
- Singapore
- Spain
- Sri Lanka
- Sweden
- Switzerland
- Taiwan
- Tajikistan
- Thailand
- Turkmenistan
- Ukraine
- Uzbekistan
- Viet Nam
- New York
- Ohio
- Washington
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
Products, services and licensing
Product / Service / Licensing
technology-based training tool. SWIFT is a sophisticated adaptive
learning environment into which virtually any course content
(text, graphics, video, sound, animation and simulations) can be
easily inserted. The learning environment is already created in
SWIFT, therefore no programming skills are required. Preparing
courses for insertion into SWIFT takes an average of 2-8 hours of
preparation for every 1 hour of instruction.
Gemini actively participates in research joint ventures nationally
and internationally, dedicating significant resources to research
and development in applying artificial intelligence techniques
to training, implementing progressive learning methods and
staying cognizant of the latest developments and trends in Open
Systems. The company is currently undertaking research to
determine the effectiveness of the SWIFT interface for secondary
and post-secondary audiences. Gemini entered into an
international joint research venture to provide an ISDN link and
extension toolkit for SWIFT for distance learning. This is one
of only three private company proposals chosen for the Canada-EC
agreement for Scientific and Technological Cooperation. Partners
include Condat from Berlin, Germany, the European Association for
Distance Teaching Universities (EADTU) of De Heerlen, The
Netherlands and CITI of Laval, Quebec. Gemini has also been
invited to participate in three centres of excellence proposals:
Telelearning, led by Simon Fraser University; Technology Based
Learning, led by the University of Calgary and McMaster University
and Telemedicine, led by the University of Calgary Faculty of
Medicine.
which provides an entirely new approach to the development of
interactive CBT. SWIFT is the only CBT development tool in the
world that porvides an Adaptive Learning Environment, adaptive
testing, and implements SGML (Standard Generalized Markup
Language) an ISO standard.
ConnectIT Category Description: TRAINING Authoring Tools
ConnectIT-keywords: CBT, SGML, Adaptive Learning Environment,
Adaptive Testing, Distance Education
(simplified and tradional) is apporximately 12 hours of fully
interactive, comprehensive training and exercises. SWIFT will
test your knowledge first and then adapt the course specifically
to your needs or allow you to surf directly to any topic for easy
review.
ConnectIT Category Description: Educational Softwares
Computing
ConnectIT-keywords: CBT, Internet training, SGML, Adaptive
Learning Environment, Adaptive Testing, Distance Education
approximately 14 hours of fully interactive, comprehensive
training andexercises. SWIFT will test your knowledge first and
then adapt the course specifically to your needs or allow you to
surf directly to any topic for easy review.
ConnectIT Category Description: Educational Softwares
Computing
ConnectIT-keywords: CBT, SGML, HTML training, Adaptive Learning
Environment, Adaptive Testing, Distance Education
Market
Market profile
Alliances:
Strategic alliances:
STRATEGIC RELATIONSHIPS:Alberta Research Council - SWIFT has been developed in two joint
research projects with the Alberta Research Council.
Foothills School Division - partnered with Gemini to implement
SWIFT for the purposes of conducting usability studies in a
secondary education environment and provide feedback from
students
and teachers for continued development.
Kenonics Controls Inc. - a Course-Added-Reseller for SWIFT, are
developing a gas measurement course for a client and plan to
distribute the end-user SWIFT course worldwide.
Oracle Corporation - Gemini is a Service Provider for the
delivery of end-user training.
University of Calgary - several professors from the University,
representing different faculties, beta test new releases of
SWIFT and sit on the SWIFT Steering Committee.
GEOGRAPHIC MARKET ACTIVITIES AND INTERESTS:
Gemini is seeking Reseller partners and SWIFT Distributors
worldwide
Value-Added Partners - enhance existing services by implementing
SWIFT as a Total Solution Provider, providing a cost-effective
technology-based training solution to clients or as a Course
Added or Value-Added partner, developing course content for
implementation into SWIFT.
SWIFT Distributors - market the SWIFT (Producer's Kit) or the
expanding library of SWIFT end-user courses, including
WordPerfect
for Windows and Microsoft Word for Windows. Course library
distributors include retail chains, wholesalers or training firms
with an infrastructure in place to manage higher volumes of
product with minimal requirement for product expertise and
support.
SWIFT (Producer's Kit) Distributors will work closely with
Gemini.
An excellent business reputation and compatibility with the
business interests and attitudes of Gemini is essential as is an
established client-base and experienced team of dedicated sales
professionals.
Geographic markets:
Export experience:
- Netherlands
- United Kingdom
- United States
- California
- Massachusetts
- Texas
Actively pursuing:
- Afghanistan
- Albania
- Algeria
- Armenia
- Australia
- Austria
- Azerbaijan
- Bangladesh
- Belarus
- Belgium
- Bhutan
- Brazil
- Brunei Darussalam
- Bulgaria
- Cambodia
- China
- Czech Republic
- Denmark
- Estonia
- Finland
- France
- Georgia
- Germany
- Gibraltar
- Greece
- Hong Kong
- Hungary
- Iceland
- India
- Indonesia
- Ireland
- Italy
- Japan
- Kazakhstan
- Korea, Democratic People's Republic of
- Korea, Republic of
- Kyrgyzstan
- Lao People's Democratic Republic
- Latvia
- Lithuania
- Luxembourg
- Macao
- Malaysia
- Malta
- Mexico
- Moldova, Republic of
- Mongolia
- Montenegro
- Nepal
- Norway
- Pakistan
- Philippines
- Poland
- Portugal
- Romania
- Russian Federation
- Serbia
- Singapore
- Spain
- Sri Lanka
- Sweden
- Switzerland
- Taiwan
- Tajikistan
- Thailand
- Turkmenistan
- Ukraine
- Uzbekistan
- Viet Nam
- New York
- Ohio
- Washington


| Fig 1 |
Conversion of near-surface wind speeds to country-wise aggre ... |
| Fig 2 |
Impact of strong climate change on backup energy needs in Eu ... |
| Fig 3 |
Impact of climate change on backup energy needs in Europe fo ... |
| Fig 4 |
Impact of strong climate change on backup energy needs for a ... |
| Fig 5 |
Change of the duration of periods with low wind generation. ... |
| Fig 6 |
Change of the duration of periods with low wind generation. ... |
| Fig 7 |
Impact of strong climate change on the seasonal variability ... |
| Fig 8 |
Assessment of long low-wind periods in a large CMIP5 ensembl ... |


Portable Globe and Server 5.2¶
- Overview
- Installation
- Creating a portable globe
- Portable server
- Connecting to a portable globe
- Command line reference
Overview
The Google Earth Enterprise Portable Server solution enables organizations to access portions of their custom globes in the field when no network access may be available or possible. Using a web interface, end users may select an area of interest to download from a Google Earth Enterprise Server for offline use on their Linux or Windows laptop with the Portable Server application.
All data available within a specified area of interest is downloaded and stored in a portable globe, including all high-resolution imagery, terrain, vector data, KML files, and searchable Point of Interest (POI) locations. Outside of the specified area of interest, only low resolution imagery and terrain will be stored in a portable globe. These levels of resolution can be specified when the globe is cut.
Portable globes may be specified, generated, and downloaded in as little as a few minutes — depending on the area of coverage — to support rapid preparation for first responders. Larger globes may be built in advanced preparation for responders to have ready on the shelf.
The Portable Server solution is made up of two applications:
- The globe cutter tool, which is installed on a production Google Earth Enterprise Server system hosting a 3D database. This tool allows end-users and administrators to select, package, and download a portion of the 3D Earth as a portable globe file.
- The portable server is installed on Linux or Windows machines in the field. It can operate in a single-user mode for complete offline usage by one user, or can broadcast a portable globe so that multiple Portable Server users, and/or mobile users with compatible Android-based smart phones, can view the same globe.
Note
The Portable Server solution can also create portable maps from a 2D map source. This document uses the term portable globe only, but instructions apply to both globes and maps.
Installation
This section describes installation of the two applications that make up the Portable Server solution.
Globe cutter installation
The portable globe cutter tool is installed with Google Earth
Enterprise Server Open Source. Globe cutting is disabled by
default; to enable it you must set the --enable_cutter
flag
for geserveradmin
from the command line:
# geserveradmin --enable_cutter
By default, the cut globes will be stored in the
/opt/google/gehttpd/htdocs/cutter/globes
directory. The cut
globes can be large, and many servers do not have sufficient
storage allocated in this directory for multiple globes. If this
is the case for your server, you may consider designating a
different directory as the storage area for the cut globes.
Portable globe server installation
The portable server is supported on:
- Linux distributions Cent OS 7, RHEL 7, Ubuntu 14, Ubuntu 16
- Windows 7 and 10
Refer to the Portable Server Wiki page for build and install instructions.
Creating a portable globe
Cutting a globe is accomplished with a simple web interface. You will use your mouse, or import a KML, to define a polygon, which defines your ‘area of interest.’ This polygon not only defines the area that will display high-resolution imagery, but is also used by Fusion to create a localized search database.
Note
The globe cutting processes are CPU and disk intensive, as they are retrieving all data within the specified polygon from the Earth Enterprise Server. This can affect the overall performance of the Server, including slowing end-user access.
To mitigate performance impact to end users, you may consider:
- Limiting the number of users with access to globe cutting.
- Creating pre-cut portable globes to host as downloadable files for portable users.
- Operating a separate GEE Server specifically to support on-demand globe cutting needs.
Before you begin
Enable the cutter
Before cutting a globe, you must enable the cutter from the command line:
# geserveradmin --enable_cutter
Note
About authentication and SSL: Cutting is not currently supported on globes that require end-user authentication, e.g., LDAP. One workaround is to allow unauthenticated access from localhost on your Earth Enterprise Server. Refer to Apache documentation to enable such a configuration. Cutting a globe over HTTPS is supported; however the SSL certificate of the target server will not be verified during cuting.
The globe cutter interface
To create a portable globe, point your browser to
http://yourserver/cutter
, where yourserver
is the server
on which Earth Enterprise Server is running. The Globe Creator
page appears.
Select the globe you wish to cut your portable version from in the drop-down menu.
Note
Additional options can be shown by clicking on the Advanced button after a cut region has been selected. These options are, namely, Polygon level. This setting is useful when cutting with large polygons, e.g., use 12 for a country-sized polygon and 18 for a city-sized polygon. Additional advanced settings may be offered in future versions. Use caution when changing them as they may dramatically increase build times and globe sizes.
Globe name
The globe name defines the file name of this globe; it will be
created as a .glb
file, which is a single-file format for
sharing Google Earth Enterprise globes. Spaces, slashes, and
double dots (..) will be converted to underscores in the saved
globe name.
We recommend using a descriptive name for each globe, so that others will know what geographic area, or what mission, the globe was created for.
Note
Building a globe will overwrite any existing globes with the same name. If multiple users are cutting globes, we recommend assigning unique prefixes to each user for their globe names to ensure that files are not accidentally overwritten.
Drawing the polygon
Once the globe name has been specified, you can define the geographic region to be cut by drawing a polygon on the globe. There are two ways to draw the polygon, one of which has been deprecated.
Defining the polygon with KML
You can use a KML to define the polygon(s). The KML should be
complete, and may contain single or multiple
<polygon> </polygon>
elements. To insert your KML:
- Select the Enter polygon as KML checkbox.
- Paste your KML into the text field.
- Click outside of the text field. Your polygon appears on the map, if you are running the deprecated Google Earth plug-in.
Hand drawing the polygon
This method is only available if you are have the deprecated Google Earth plug-in running in your browser.
First, using the navigation controls in the plugin, zoom in to the region of interest. To use your mouse to define the polygon, click the polygon icon in the globe window.
Then, click the globe to define each point. You can use the navigation controls on the right to move the globe or change zoom levels while drawing.
Double-click the final point to complete the polygon selection, at which point the polygon will change from blue to purple.
You can view the KML of the shape you have drawn by selecting the Enter polygon as KML checkbox.
Globe resolution
The polygon you specified in the previous step defines your ‘area of interest.’ This area will contain high-resolution imagery and data, and search tabs will be created for information that lies within this zone. The maximum and minimum resolutions are specified as integers between 1 and 24. These correspond to the zoom levels that are used in the Fusion server.
Minimum resolution
The zoom level for the polygon area is specified in the Maximum resolution to extract field.
A minimum zoom level of 5-7 will present a decent-looking world to
the user and will most likely include vector layers such as
international boundaries and state boundaries and main cities
without affecting the size of the .glb
file very much. For
example:
- A cut globe with minimum and maximum resolution values set to 5 is 10 MB.
- A cut globe with minimum and maximum resolution values set to 6 is 41 MB.
- A cut globe with minimum and maximum resolution values set to 7 is 120 MB.
These numbers are small in comparison to the overall size of your globe when a suitable maximum resolution has been selected. For example, a globe that contains all of the city of Atlanta, GA, USA in 1-foot resolution requires approximately 5 GB of storage. Even level 7 imagery, at 120 MB, is a small percentage of the overall globe size.
Maximum resolution
The area outside of the defined polygon will be included in the globe at a lower resolution, which is defined within the Minimum resolution to extract field. Areas near the polygon may be included at a higher resolution.
The maximum resolution of the cut globe will be no higher than the maximum resolution of the source globe. For example, if the maximum resolution in the cutter is specified at 24, but the source imagery is at 18 (approximately 1-meter resolution), the cut globe will contain level 18 imagery. You can leave this field blank to use the highest available imagery.
You may enter a lower number to reduce the size of your globe, by not including the highest resolution imagery.
Building the globe
Click Build to start the build process. Depending on the size of your polygon, this can take from a few minutes to a few hours; likewise, file size will vary widely depending on the area selected and the desired resolution.
When the build is finished, a .glb
file is created and a
download link appears to the file’s location on the Earth Server.
Save the file into the <portable-server-unpack-directory>/data
directory with the other .glb
files. Alternately, the globe
file can be copied onto portable media like a DVD, thumb drive, or
external hard drive to be delivered to users.
The .glb
file contains all that you need to share your
portable globe — imagery, terrain, and vector assets, plus the
search database. For this reason, it is important to retain control
of your globe if it contains sensitive or proprietary information.
Search tabs
When a globe is cut, the search tabs associated with the globe are also bundled with the globe. However, because search plugins in Google Earth Enterprise run within the Tomcat / Apache instance on the Earth server, most search tabs will not work in a portable globe.
The Portable Server uses its own search framework that allows Python code stored on the portable machine to execute in place of the GEE plugin.
KML files
When a portable globe is cut from a source containing KML links in the Layer panel:
- KML files that are stored locally on the primary Earth Server will be bundled into the portable globe. Only the main KML file will be copied, not any links or files that are embedded as links in the main KML file. The default copy is not recursive.
- KML links that refer to servers other than the primary Earth Server are not copied. The layer will be visible in the client, but clicking the link will not cause any data to be displayed. If access to external servers is needed, a small KML file should be stored locally on the primary Earth Server. This KML file should contain a link to the intended external server.
These behaviors can be modified if the globe is built from the command line rather than from the GUI as described in the Command line reference section.
Historic Imagery
Historic Imagery is not supported in the portable globe as of Fusion 4.2.
There are, however, two situations in which historic imagery will be displayed:
- When the computer running the portable globe has a connection to the Earth server from which the globe was cut. In this case, historic imagery can be streamed from the Earth server. Once in the field, however, and disconnected from the Earth server, no historic imagery will be displayed.
- If historic imagery has been cached on the portable globe machine.
Otherwise, the following error message will appear:
Note
Google Earth cannot contact the imagery server to download new images.You will be able to see areas that you have been to recently, but new image areas may appear blurry.
Portable server
The portable server is a lightweight web server that runs on Linux
and Windows computers. The web server starts within seconds and
begins serving one of the globes that has been saved to the
data
directory. Once the globe is served, it can be opened in
a web browser.
Serving a globe
Copy the globe to be served into the data
subdirectory (or
whichever directory is specified as the globes_directory
in
portable.cfg
).
To start serving run the following command in the directory where you unpacked Portable Server:
python portable_server.py
Navigate to the Portable Server administrative page at
http://localhost:9335
. If you have set a customport
number inportable.cfg
, substitute that for “9335”.
You can select what globe is being served from the administrative page. Click the folder icon and you will see a screen where you can select what globe or map should be served by Portable Server.
You can shut down Portable Server from the administrative page, as well. Click the menu button, then select Quit.
Broadcasting a globe
To share a globe with others on your network:
- Make sure
disable_broadcasting
is set toFalse
in yourportable.cfg
. - If you are not already serving a globe, select the globe to serve from the Portable Server interface.
- On the Portable Server administrative page, click the Broadcast icon.
Changing the globe being served
To change the globe being served:
- Point your browser to
http://localhost:9335
. - Click the Folder button.
- Select the new globe.
If you are accessing the globe with the Google Earth Enterprise
Client, log out of the client and log back in to
http://localhost:9335
.
Connecting to a portable globe
It is possible to connect to a portable globe from a variety of platforms.
Google Earth EC
Launch the Google Earth EC client. When prompted for a server
address, enter http://localhost:9335
. If you have changed the
default port in portable.cfg
, use the new port value instead.
Google Earth API
The Google Earth Enterprise Portable Server comes with a
preconfigured HTML page that displays your globe using the Earth
API. The page relies on the discontinued Google Earth browser
plug-in to render globes, so it does not work in most recent
browsers. This page is at
http://localhost:9335/earth/earth_local.html
.
If you wish to make your own custom Earth API application, make a copy of the included file from which to start.
You can also reach the page listed above by clicking view in
browser from the administration page at
http://localhost:9335
.
Defining options in portable.cfg
The server directory under the Portable Server installation
directory contains the main configuration file, portable.cfg
.
This file defines a number of options, but is primarily used to
change the port on which the globe is served, if required.
- port: the port on which to serve the globe. Default is 9335.
- globes_directory: the directory in which to look for globe files.
- globe_name: the default globe to serve when the server is started.
- fill_missing_map_tiles: If set to True, enables pixel-filling from ancestor map tile when there are no more tile descendents.
- max_missing_maps_tile_ancestor: Limit the pixelation to 2x by 2x sized pixels.
- local_override: If set to True, Portable Server looks for all files on the server first before seeking them on the globe.
Command line reference
The following command line tools are available for the portable globe and server.
Knowledge of these command line tools is not needed for most users and system administrators. The simple cutter interface that is provided should meet the needs of nearly all users. However, if finer control is needed or if the complete creation of globes needs to be automated, these command line tools are available. The following is the series of events for creating a globe to help give a sense of what these command line tools accomplish and in what order they are run:
Building LevelFive ...
No description given. Added globe directory:
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive Ok
Saved polygon to
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/earth/polygon.kml
Convert polygon to quadtree nodes ...
Executing: /opt/google/bin/gepolygontoqtnodes --qt_nodes_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/qt_nodes.txt
--kml_polygon_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/earth/polygon.kml
--max_level=18
0 qtnodes Ok
Rewrite dbroot ...
Executing: /opt/google/bin/gerewritedbroot
--source=http://earth.localdomain/default_ge/
--icon_directory=/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/icons
--dbroot_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/dbroot.v5
--search_server=localhost
--search_port=9335
--kml_server=localhost
--kml_port=9335
--kml_map_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/kml_map.txt
8 icons
Executing: cp
/tmp/globe_builder/LevelFive_4282_1287494655.545115/dbroot.v5
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/dbroot/dbroot_localhost_9335
Ok
Grab kml files ...
Executing: /opt/google/bin/gekmlgrabber
--kml_map_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/kml_map.txt
--output_directory=/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/kml
--source=http://earth.localdomain/default_ge/
--kml_server=localhost
--kml_port=9335
0 kml files Ok
Build globe ...
Executing: /opt/google/bin/geportableglobebuilder
--source=http://earth.localdomain/default_ge/
--default_level=5
--max_level=5
--hires_qt_nodes_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/qt_nodes.txt
--metadata_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/earth/metadata.json
--globe_directory=/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive
--dbroot_file=/tmp/globe_builder/LevelFive_4282_1287494655.545115/dbroot.v5 >
/tmp/globe_builder/LevelFive_4282_1287494655.545115/packet_info.txt & Ok
685 image packets
128 terrain packets
515 vectors packets
Extract search data ...
Getting search poi ids:
http://earth.localdomain/cgi-bin/globe_cutter.py?
cmd=POI_IDS&db=default_ge
Getting search poi data:
http://earth.localdomain/cgi-bin/globe_cutter.py?
cmd=SEARCH_FILE&poi_id=&
polygon=Paste%20in%20KML%20containing%20polygon.%20If%20KML%20contains%20more
%20than%20one%20polygon%2C%20the%20first%20polygon%20will%20be%20used.
Saving search poi data:
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/search_db/gepoi_ Ok
Add plugin files ...
Executing: cp -r /opt/google/gehttpd/htdocs/cutter/template/earth/*
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/earth Executing: cp -r /opt/google/gehttpd/htdocs/cutter/template/maps/*
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/maps Executing: cp -r /opt/google/gehttpd/htdocs/cutter/template/js/*
/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive/js Rewrite JSON from: http://earth.localdomain/default_ge//query?request=Json&var=geeServerDefs Ok
Packaging globe for download ...
Executing: /opt/google/bin/geportableglobepacker
--globe_directory=/tmp/globe_builder/LevelFive_4282_1287494655.545115/LevelFive
--output=/opt/google/gehttpd/htdocs/cutter/globes/LevelFive.glb
Executing: chmod a+r /opt/google/gehttpd/htdocs/cutter/globes/LevelFive.glb
/opt/google/gehttpd/htdocs/cutter/globes/LevelFive.glb 9.62MB Ok
Deleting tmp directory as: /tmp/globe_builder/LevelFive_4282_1287494655.545115 Ok
This section uses the following typographic conventions:
| Italic | Information that the user must supply |
| Square brackets [ ] | Optional items |
gepolygontoqtnodes
Usage
- gepolygontoqtnodes --kml_polygon_file=filename
- --qt_nodes_file=filename --max_level=int
Description
Creates a list of the quadtree nodes that encompass a polygon at
the given max_level
.
Required
| --kml_polygon_file=filename | KML file containing a polygon that defines the region of interest. |
| --qt_nodes_file=filename | File where quadtree addresses are stored. |
| --max_level=int | Level of resolution of quadtree that is used to encompass the polygon. |
gerewritedbroot
Usage
gerewritedbroot --source=server_name --icon_directory=directory --dbroot_file=filename --kml_map_file=filename [--search_service=search_service_url] [--preserve_search_service] [--kml_server=server_name] [--kml_port=num] [--kml_url_path=prefix] [--use_ssl_for_kml=bool] [--preserve_kml_filenames] [--disable_historical]
Description
- Reads dbRoot and rewrites the search tabs so that they point to the given search server, port, and path.
- Optionally creates a directory of all of the icons referred to by the dbroot.
- Optionally updates the host, path, and/or file names in KML Layer URLs in the dbRoot.
- Optionally creates a text file that lists the mapping from original KML Layer URLs to their updated file names.
- Optionally removes the reference to the server for historical imagery data.
Required
| --source=server_name | Server whose dbRoot should be rewritten. |
| --dbroot_file=filename | File where the new dbRoot should be stored. |
Options
| --icon_directory=directory | Directory where the icons should be stored. |
| --kml_map_file=filename | File where the KML map of source URLs to local files should be stored. |
| --search_service=search_service_url | URL to search service. If none is provided then uses relative URL for standard Portable search. |
| --preserve_search_service | Preserve the existing search service URL. |
| --kml_server=server_name | Server to be used for KML files in the dbRoot. Default is localhost . |
| --kml_port=num | Port to be used for KML files in the dbRoot. Default is 8888 . |
| --kml_url_path=prefix | Path in new URL to prefix KML file name. Default is kml . |
| --use_ssl_for_kml=bool | Use https instead of http for accessing KML files. Default is false . |
| --preserve_kml_filenames | Preserve the existing file names of any KML files. Not used when creating portable globes. |
| --disable_historical | Remove the reference to the server to obtain historical data. |
gekmlgrabber
gekmlgrabber --kml_map_file=/tmp/kml_map
Usage
- gekmlgrabber --kml_map_file=filename --output_directory=path
- [--source=server_name] [--kml_server=server_name] [--kml_port=num*] [--kml_url_path=prefix] [--use_ssl_for_kml=bool] [--no_recurse=bool] [--ignore_absolute_urls=bool]
Description
Reads KML references, retrieves them from network, and copies them
into local files. If the --no_recurse
flag is not set, it does
the same for any additional KML files referenced within the given
KML files.
Required
| --kml_map_file=filename | File where map of KML source URLs to local files are stored. |
| --output_directory=path | Directory where local KML files are to be stored. |
Options
| --source=server_name | Source for KML files. Default is localhost . |
| --kml_server=server_name | Server to be referenced in the dbroot for KML files. Default is localhost . |
| --kml_port=num | Port to be referenced in the dbroot for KML files. Default is 9335 . |
| --kml_url_path=prefix | Path in new URL to prefix KML file name. Default is kml . |
| --use_ssl_for_kml=bool | Require https:// instead of http:// for accessing KML files. Default is false . |
| --no_recurse=bool | Do NOT make all KML files linked within the KML files local files as well. Default is false . |
| --ignore_absolute_urls=bool | If KML is linked with a full URL address (http://server/...) , leave it as it is. Default is false . |
geportableglobebuilder
geportableglobebuilder --source=http://myserver --max_level=18 --default_level=8 --hires_qt_nodes_file=qt_nodes.txt --globe_directory /tmp/my_portable_globe
Usage
- geportableglobebuilder--source=server_name --globe_directory=path
- [--max_level=num] [--default_level=num] [--hires_qt_nodes_file=filename] [--dbroot_file=filename] [--nowrite]
Description
Creates a set of packet bundles and other associated files. These
files can be combined into a globe file with
geportableglobepacker
.
Required
| --source=server_name | The source globe from which the sub-globe is to be derived. |
| --globe_directory=path | Directory where the portable globe should be built. |
Options
| --max_level=num | Level of resolution of the quadtree above which no packets should be saved. Default is 24 . |
| --default_level=num | Level of resolution of the quadtree for which all packets are kept independent of the
region of interest. Default is 7 . |
| --hires_qt_nodes_file=filename | Name of file containing the quadtree nodes that define the high-resolution area of the globe. Default is no file. |
| --dbroot_file=filename | Name of file containing the dbRoot that should be saved with the globe. Default is no file, in which case the dbRoot is read from the source. |
| --metadata_file=filename | Name of file containing boundary metadata that should be saved with the globe. Default is no file, in which case no metadata file is included. |
| --no_write | Do not write packets; print out the total size of the globe. |
geportableglobepacker
Usage
geportableglobepacker --globe_directory=path --output=filename [--make_copy=bool] [--is_2d=bool]
Description
Packs up all globe files into a single file. If --make_copy
is
set to true
, the globe directory is undisturbed. If not, then
the globe directory is rendered unusable, but the command can run
considerably faster.
Options
| --globe_directory=path | The directory containing the globes to be packed. |
| --output=filename | The file to which to save the packed globe, including a file path if desired.
The file name should use a .glb file extension. |
| --make_copy=bool | Make a copy of all files so that the globe directory is not disturbed. Default is false . |
| --is_2d=bool | Are we packaging a 2D map. Default is false . |


We’ve all heard that if it sounds too good to be true… it probably is. Fortunately, this isn't one of them
Refund Advocate LLC is located in Wyoming, we are a group of experts at auditing government records across the country, locating monies owed to private individuals and companies, and fighting on those individuals’ behalf. If you have received a call or a letter from us, it is because we've found funds being held by the government that may rightfully be owed to you.
We know the "ins and outs" of government agencies in all states. If a government agency is holding your funds, we know how to get them! After a certain period of time, the funds are forfeited to the government.
The agencies holding the assets often have many specific requirements that must be followed for proving your entitlement to the claim and submitting your request, so it’s always best to have professionals on your side.
If a claim for your funds isn't made in time, the funds often are forfeited to the agency holding them. Meaning, they cannot be claimed. It's your money, and the government shouldn't be able to take it from you. Our mission is to ensure that this doesn’t happen. We audit government files and documents for these unclaimed funds, and when we find them, we make it our responsibility to reunite them with the individuals & families they are rightfully owed to.
To help Individuals, Families and Businesses claim funds that have been lost to them. For so many an unexpected payday can make a big difference. We want to make sure the government doesn't end up with it!


#include <bingham_fluid.h>
|
|
| double | EffectiveViscosity (double Density, const TShapeFunctionValues &rN, const TShapeFunctionGradients &rDN_DX, double ElemSize, const ProcessInfo &rProcessInfo) override |
| | EffectiveViscosity Calculate the effective viscosity at given integration point using the Bingham constitutive model. More...
|
| |
◆ DofsArrayType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ DofsVectorType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ EquationIdVectorType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ GeometryType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Geometry type (using with given NodeType)
◆ IndexType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ MatrixType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Matrix type for local contributions to the linear system.
◆ NodesArrayType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Definition of nodes container type, redefined from GeometryType.
◆ NodeType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ PropertiesType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ ShapeFunctionDerivativesArrayType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Type for an array of shape function gradient matrices.
◆ ShapeFunctionDerivativesType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Type for a matrix containing the shape function gradients.
◆ ShapeFunctionsType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Type for shape function values container.
◆ SizeType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ VectorType
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Vector type for local contributions to the linear system.
◆ BinghamFluid() [1/4]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Default constuctor.
- Parameters
-
| NewId | Index number of the new element (optional) |
◆ BinghamFluid() [2/4]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Constructor using an array of nodes.
- Parameters
-
| NewId | Index of the new element |
| ThisNodes | An array containing the nodes of the new element |
◆ BinghamFluid() [3/4]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Constructor using a geometry object.
- Parameters
-
| NewId | Index of the new element |
| pGeometry | Pointer to a geometry object |
◆ BinghamFluid() [4/4]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Constuctor using geometry and properties.
- Parameters
-
| NewId | Index of the new element |
| pGeometry | Pointer to a geometry object |
| pProperties | Pointer to the element's properties |
◆ ~BinghamFluid()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
◆ Create() [1/2]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| Element::Pointer Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::Create |
( |
IndexType |
NewId, |
|
|
GeometryType::Pointer |
pGeom, |
|
|
PropertiesType::Pointer |
pProperties |
|
) |
| const |
|
inlineoverride |
Create a new element of this type.
- Parameters
-
| NewId | Index of the new element |
| pGeom | A pointer to the geometry of the new element |
| pProperties | Pointer to the element's properties |
◆ Create() [2/2]
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
Create a new element of this type.
Returns a pointer to a new element, created using given input
- Parameters
-
| NewId | the ID of the new element |
| ThisNodes | the nodes of the new element |
| pProperties | the properties assigned to the new element |
- Returns
- a Pointer to the new element
◆ EffectiveViscosity()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| double Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::EffectiveViscosity |
( |
double |
Density, |
|
|
const TShapeFunctionValues & |
rN, |
|
|
const TShapeFunctionGradients & |
rDN_DX, |
|
|
double |
ElemSize, |
|
|
const ProcessInfo & |
rProcessInfo |
|
) |
| |
|
inlineoverrideprotected |
EffectiveViscosity Calculate the effective viscosity at given integration point using the Bingham constitutive model.
The Bingham model is implemented here using a regularized formulation, as the viscosity should be infite while the stress is smaller than the yield stress. The implemented constitutive relation is
stress(i,j) = ( mu + ( 1 - exp(-m*gamma_dot) )* yield_stress / gamma_dot ) * strain_rate(i,j)
where gamma_dot is the second invariant of the strain rate (2*SijSij)^0.5 and m is a regularization coefficient. For details on the formulation see the phd thesis of A. Larese, "A coupled Eulerian-PFEM model for the simulation of
overtopping in rockfill dams" (2012) Universitat Politecnica de Catalunya.
mu is interpolated from the nodal VISCOSITY values, yield_stress and m are read from rProcessInfo values YIELD_STRESS and REGULARIZATION_COEFFICIENT respectively.
- Note
- This assumes that the underlying fluid element provides EquivalentStrainRate(rDN_DX) and EvaluateInPoint(value,VARIABLE,rN) methods.
- Parameters
-
| Density | The fluid's density at the integration point. |
| rN | Nodal shape functions evaluated at the integration points (area coordinates for the point). |
| rDN_DX | Shape function derivatives at the integration point. |
| ElemSize | Representative length of the element (unused for Bingham). |
| rProcessInfo | ProcessInfo instance passed from the ModelPart, containing additional data |
- Returns
- The effective viscosity, in dynamic units (Pa*s or equivalent).
◆ Info()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| std::string Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::Info |
( |
| ) |
const |
|
inlineoverride |
Turn back information as a string.
◆ KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION |
( |
BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients > |
| ) |
|
◆ PrintData()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| void Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::PrintData |
( |
std::ostream & |
rOStream | ) |
const |
|
inlineoverride |
◆ PrintInfo()
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
| void Kratos::BinghamFluid< TBaseElement, TShapeFunctionValues, TShapeFunctionGradients >::PrintInfo |
( |
std::ostream & |
rOStream | ) |
const |
|
inlineoverride |
Print information about this object.
◆ Serializer
template<class TBaseElement , class TShapeFunctionValues = typename TBaseElement::ShapeFunctionsType, class TShapeFunctionGradients = typename TBaseElement::ShapeFunctionDerivativesType>
The documentation for this class was generated from the following file:
- /home/runner/work/Documentation/Documentation/master/applications/FluidDynamicsApplication/custom_elements/bingham_fluid.h


A minecraft resource pack, forked from the original resource pack 'Dandelion', featuring mod support, many improved and new vanilla items & models and 1.13. Although not worked on extensively anymore, I consider it one of my main projects
A variety of useful tools, currently featuring a random number generator and an extensive minecraft model creator. Along with Dandelion With Mods and this website in general, it is one of my main projects
Slider89 is a framework for easily creating and manipulating fully customizable CSS sliders for your website, featuring functions and practices for every purpose
A WebGL 2 learning log