Back to Policies and Guidelines home
Designates a mandatory point (policy).
Designates a recommended point (guideline).
New projects must use an OSI-approved, permissive open-source license (e.g., Apache, Apache-2.0 with LLVM-exception, MIT, or BSD 3-Clause).
- Details
- Similarly, any required dependencies must use an OSI-approved license that is considered compatible with the open-source permissive license for distribution purposes. Non-critical optional dependencies may use any OSI-approved license.
- Rationale
- A permissive open-source license is friendlier to use by commercial entities. Note that strong copyleft licenses (e.g., GPL) are not considered compatible with permissive licenses. Weaker copyleft licenses (e.g., LGPL or GPL v2 with runtime exception) can be considered compatible for distribution purposes.
- Ref
- xSDK M7
Provide a list of dependencies and their associated licenses in SPDX format.
- Details
- The SPDX License List is a list of commonly found licenses and exceptions used in open-source software that enables easy and efficient identification of such licenses. At the minimum, this should be done for all internally bundled source code, and optionally for external dependencies as well. It should preferably be placed in the NOTICE (or LICENSE) file in the root of the repository or in the bottom of a README.md.
- Examples
- See the Spack COPYRIGHT file.
- See the Cardioid README file.
- Rationale
- This provides important information in a concise format to users and projects who are making decisions about whether to adopt RADIUSS products without forcing them to track down this information for each dependency.
- Ref
- See this link for LLNL Software Licensing Guidelines.
Existing projects should consider moving to an OSI-approved, permissive open-source license for existing projects (e.g., Apache, MIT, or BSD 3-Clause).
- Details
- Unlike M.lic.1, we recognize that projects that have existed for a long time may have adopted non-permissive licenses at their outset and it may be infeasible to convert. But the long-term benefits may make this worth considering.
- Rationale
- See M.lic.1
Package your installation and provide automated builds of dependencies using Spack.
- Rationale
- Automating the build process prevents duplication of effort and allows others to build a copy of the code and to incorporate needed fixes in dependency tools and libraries. Spack is a package management tool that allows easy configuration with multiple dependency versions, configurations, platforms, and compilers.
- Ref
- Enforce WSC 1.1 and WSC 1.2
- Tag
- Tools
Compilable projects (e.g. those written in C++ and/or Fortran) must be buildable with CMake.
- Details
- We suggest considering BLT (Build, Link and Test) which handles known CMake limitations and provides a set of templates to easily stand up a robust CMake-based build system.
- Rationale
- Consistent use of CMake and BLT will enable individual users, computing centers, and package managers (such as Spack) to install the package in a way that is compatible with other RADIUSS products on the same system.
- Ref
- WSC 3.1
- Tag
- Tools
Provide build options for production (optimized) and debug deployments.
- Rationale
- Production versions should not be compiled with debug symbols and should include platform-specific optimizations so long as they pass all tests. Debug versions should be available for users who can self-assess bugs and thus provide more specific bug reports or fixes.
- Ref
- Smart Libraries practice 19
Version number and build characteristics must be easily accessible
- Details
- Each product API must include the functionality to return the current version number of the software and indicate which configure/CMake and compiler options were used to build the package. For development versions of the software, a build or install should allow to trace back to the commit ID of the source used.
- Rationale
- This allows users to make an inventory of what they have, which is critical for reproducibility, and which can aid debugging and configuration management.
- Ref
- Smart Libraries Practice 10 / xSDK M8
Use a limited, unique, and well-defined symbol, macro, library, and include file namespace.
- Details
- i.e. “Don’t pollute the global namespace”. For example, there should be no publicly visible include files with generic names such as
utils.h
, a package namedlibutil.a
, or macros named YES or TRUE. Namespacing of include files can be handled either by prepending installed include files with a package name (e.g.,<XXXutils.h>
) or by placing and referencing all of them in a subdirectory with the package name (e.g.,<XXX/utils.h>
).- Rationale
- Library developers must acknowledge that their software will be built as part of much larger packages. In that context, the use of generic names in the global namespace increases the chance that users of their library will run into build- and link-time errors that must be worked around.
- Ref
- Smart Libraries Practice 18 / Less restrictive than xSDK M9
Use MPI in a way that is compatible with other products.
Details:
- Each RADIUSS product that utilizes MPI must restrict its MPI operations to MPI communicators that are provided to it and not use directly
MPI_COMM_WORLD
.- Products must use configure tests or version tests to detect MPI 2 or MPI 3 features that may not be available; it should not be assumed that a full MPI 2 or MPI 3 implementation is available.
- Products can change the MPI error-handling mode by default but should have an option to prevent them from changing the MPI error handling (which may have been set by another package or the application). The product should also behave appropriately regardless of the MPI error handling being used.
- This rule also implies that you should not mock interfaces in a way that overrides the public API of other packages. For example, including a header file from your package should not cause other code in the same compilation unit to use a mocked MPI interface instead of the expected MPI.
- Ref
- xSDK M3
The source code must be version controlled using Git.
- Rationale
- Version control is essential for collaborative development and change tracking. Git is the most popular version control system by a wide margin, many sophisticated web-based collaboration tools are available for it, and new developers will be immediately productive in your Git repository.
- Ref
- WSC 2.1
- Tag
- Tools
Provide a transparent, online contribution process based on pull requests and issues collection. The preferred platform is GitHub.
- Rationale
- GitHub is one of the most-used repositories of open-source software that includes collaboration tools such as issue tracking, pull requests, and wikis. Pull requests allow project maintainers to review changes, comment, and iterate with developers before new features are committed to a code base. Pull requests and branching simplify management of large numbers of contributions (particularly contributions across teams), and they enable many features to be developed concurrently. The product maintainer can review code and associated test results before merging it into a public branch. Pull requests can also be linked to GitHub issues, which can be created by anyone.
- Ref
- Enforce WSC 2.3, 2.4, part of xSDK M10 and R1.
- Tag
- Tools
Develop documentation from a readable plain-text format that can be publish documentation in a web-based format or as a PDF
- Rationale
- Web-based documentation is accessible, searchable, and linkable. It allows users to easily point each other to relevant parts of the documentation in emails, the code, and other documents. It also makes it easier to manage under revision control (see also M.doc.3)).
- All of these tools allow developers to create web-based manuals and API documentation automatically, using a familiar, non-HTML plain-text format.
- Examples
- Ref
- WSC 4.1
- WSC 4.4
Provide a concise description of the software functionality wherever your project is summarized
- Details
- The description should typically be answering “What is it for ?” and “Should I use it ?”, and not simply an extension of an acronym or otherwise fully generic description that does not differentiate the software from other products. This description (1-3 sentences) should be consistently used in:
- The GitHub host web interface (modified with the ‘Edit’ button)
- The top of the root README.md
- The corresponding Spack package
- Rationale
- Developers who come across your project or repository should be able to determine almost immediately if your project is applicable to their needs. The GitHub repo description is also used as the basis to automatically describe each project at https://software.llnl.gov/.
Version control your documentation consistent with and alongside your source code.
- Rationale
- When documentation is version controlled consistent with the corresponding source code, developers and users can easily retrieve the documentation associated with any revision of the code. Versioning documentation along with source code (in the same repository) also allows and encourages any developer to easily contribute to the documentation as part of their pull request.
- Ref
- WSC 4.3
Provide a documented, reliable way to contact the development team.
- Details
- Contact can be through email address, a web-based submission form, or via GitHub (issues, pull requests). In the case of email, a generic name is preferred that can be reflected to alternate or multiple team members as needed. Joining a mailing list should not be required.
- Rationale
- Users should be able to easily contact the development team in order to report bugs or request basic assistance. RADIUSS can provide support for those libraries included in the RADIUSS project for basic fixes and support.
- Ref
- xSDK M5
Provide and maintain example source code along with documentation.
- Details
- Examples should be compiled and tested as part of a release to make sure they are kept up to date with API changes. New examples should be added when major new features are released, or existing examples should be extended to include those new features. Existing proxy apps are a potential good starting place.
- Rationale
- This recommendation serves two purposes. The first is for documentation of the concrete usage of the product, training, or new feature demonstration. The second is for maintenance purpose as these examples provides a primary set of tests for non-regression or installation verification (see Testing and Continuous Integration)
Provide a documented policy for handling pull requests from external contributors
- Details
- Successful open source projects will attract bug fixes and feature development from the external community, preferably via pull requests on GitHub associated with a particular issue in the tracker. Teams should have a policy documenting expectations for when a pull request may be accepted, rejected, or returned for modifications.
- Rationale
- Developers providing fixes will be discouraged from future contributions if they feel they are being ignored. Similarly, they are probably using a branched version of your software to workaround the fix they provided, which leads to additional inefficiencies.
Use regression tests in the development process.
- Rationale
- Regression tests prevent new features from affecting prior functionality, and they allow developers to have more confidence in their changes when modifying code.
- Ref
- WSC 5.1
Provide a test suite for verifying correctness of build and installation.
- Details
- A series of tests (including unit tests) should be runnable by anyone after the package is built to verify a correct build. The installation should also provide tests – which could derive from or be the same as example codes – must be run and installed alongside the library for future verification.
- Rationale
- An executable test suite gives users confidence that the product gives correct results. It is also recommended that at least a significant subset of the tests be can be run in batch-only environments.
- Ref
- xSDK M2
Provide a development test suite along with the source code for external contributors.
- Details
- The Git repository must contain test problems an easy way to run them and verify correctness for developers who are working on remote systems. External contributors must also have access to any results from continuous integration pipelines run against their changes before they make a pull request.
- Rationale
- External contributors should be able to test there code to the same standard as the development team. This ensure easier integration of new contribution and transparency in the process.
Use continuous integration (CI).
- Details
- Example CI systems in use by RADIUSS products:
- RAJA with Travis CI on GitHub. See .travis.yml
- VisIt with Circle CI on GitHub. See .circleci/config.yml
- MFEM with AppVeyor on GitHub. See .appveyor.yml
- Ascent with Azure Pipelines on GitHub. See azure-pipelines.yml
- Rationale
- CI helps to prevent integration problems by identifying issues as they arise instead of allowing them to compound. This process helps reduce rework, cost, and time. Examples of CI tools include Travis CI for projects hosted on GitHub, or GitLab CI for projects hosted on a GitLab instance such as LC-GitLab. Some products may use Azure Pipelines in the future.
Continuously check compatibility with different compilers and versions.
- Details
- During the development process, tests should include compilation across a matrix of compilers and compiler versions, including both open source and vendor-proprietary when available
- Rationale
- This helps to guard against platform-specific or compiler-specific errors.
Ensure code quality/health in an automated manner.
- Details
- Example tools:
- Asan (AddressSanitizer)
- clang-tidy
- cppcheck
- cpplint
- Rationale
- Code quality checkers help to prevent code constructs that may result in errors in future environments where the code may run. They also reduce noise in build output that may obfuscate real errors. Code style checkers can also help enforce consistent style across a project.
- Ref
- WSC 5.4
Give best effort at portability to common HPC platforms and compiling toolchains.
- Details
- Projects should also share information about the preferred and supported platforms and toolchains.
- Rationale
- Better portability ensures a broad base of users. This includes, but is not limited to, standard Linux distributions, GNU, Clang, and vendors’ compilers.
- Ref
- xSDK M4
Support Apple MacOS (Xcode) and Microsoft Windows (Visual Studio).
- Rationale
- This allows code development on common desktop and laptop machines.
- Ref
- xSDK M4


This is not my first encounter with Salvia Divinorum, however it is probably the most intense 'trip' it has provided me with so far.
First off, let me state that I'm by no means an experienced drug user. I've been smoking marijuana for the last 4 months and have only recently, out of curiosity, decided to try Salvia.
I have somewhat of a fascination with the way in which our mind interprets 'reality' and often find myself questioning reality itself. I'll emphasize this thought a little later on. Now, without further ado; My Salvia Divinorum reality compromise!
-------------
For this trip, I was at a friends house (here forth deemed: Friend-A). Another friend was also present (here forth deemed: Friend-B). The plan was to each take a turn while the other two served as 'sitters'. We waited until Friend-A's parents and siblings were all asleep before Friend-A broke out a home-made water bong made from an empty 'Pringles' cardboard tube. Yes, I know. It doesn't get much more ghetto than that...
I filled it with water and when I returned to Friend-A's bedroom I was greeted with a small package of '20x Salvia Divinorum'. Not sure how much I needed, I tapped the bag until a small mound of the dark flakes had collected and was told by Friend-B 'That'll get you fucked.' I asked who was to go first and they both said that I should. Having no objections I took the water bong over to the window and lit up.
Having the understanding that Salvinorin-A is released under very high temperatures, I kept the lighter on throughout the entire hit and saw that it was burning a very hot red, almost white glow that took moments to fade even after I put the bong down. Even using a water bong, the smoke still became quite hot as I neared the end. Not wanting to waste any Salvia, I endured it and handed the bong to Friend-A. Holding my breath, I moved away from the window onto the bed where I sat myself down comfortably as I waited for the effects to set in. After about 30 seconds I exhaled. I explained to my friends how, like previous trips, I can sort of feel reality slipping. My vision seems to move down and to the left a bit, and vision seems to lag slightly behind if I turn my head.
During all my salvia trips including this one, I always have a consistent feeling near the beginning. I feel like I'm going to feel a little distorted, but the salvia isn't going to do anything significant. I feel that I still 'see' reality. I still 'see' my friends, so there is no way that salvia can really take me much further. And like always, I was wrong.
It started out with me simply trying to explain how I felt. I would simply try to tell my friends that I feel distorted, but that I'm still very aware of the fact that I'm on salvia, and that I'm in control. From that point, things steadily changed. They would laugh when I tried to speak to them. I was confused. I hadn't said anything funny as far as I knew (later, I'm told I was speaking complete gibberish). Each time I spoke they would laugh, exchange glances, and then both set their gazes on me.
At this point I simply said 'What the hell?' Immediately they started laughing at me again. Knowing that they wouldn't be laughing so hysterically at nothing, I began to wonder if something was wrong with me. I had now completely forgotten that I had smoked any salvia (which is where things really started to feel real). I was extremely confused. In my confusion, I said again 'What the hell?' Once again, they burst out laughing but continue to watch me, waiting for what I'll do next. I don't understand why they are laughing at me, which is why I keep saying 'What the hell?'
And then it hits me. I suddenly realize that I'm in a constant loop. The best way I could describe it would be in comparison to a progress bar of a process on a computer, going from 0% - 100%. In this loop, I would say 'What the hell?' and that would be a certain percentage, and then Friend-A and Friend-B would laugh at me, completing the loop and taking it to 100%. After it hit 100%, it would go back to 0% and start over. I said 'What the hell?' again, and they laughed. I did this multiple times to see if they laughed each time, and sure enough, they did. I told them 'Stop it'. It felt like I had to focus all my energy to say any words other than 'What the hell'. They looks at me, and in my reality they were thinking something along the lines of 'You cannot break the loops, you are slowing the cycle, but eventually it will make 100% and start over.'
At this point I can't seem to form the words for the feeling I had. I could actually SEE the pattern. I could see that I was in my friends bedroom, in the dark, with the glow of his computer monitor in my peripherals. At the same time though, I could visually SEE the pattern of the loops forming the reality of 'life' as we know it. I was the only one that could see it, but I couldn't communicate to my friends to help break the cycle to free me. I was trapped.
At one point, I simply stopped speaking. I thought that if I don't start the loop, then they can't finish it. Sure enough it seems to work. The loop progress didn't stay at 0% though. It seems that it was trying to work around it to complete the loop in a different manner. Visually I saw that it was working and was scared that I truly couldn't do anything about it. That is when I saw Friend-A, who was now watching some anime on the computer, reaching for the monitor to turn it off. His monitor was the only source of light in the room, and I thought that if the light was gone I would have absolutely no connection to any means of reality at all. I quickly barked at him 'Don't touch it'.
I then suddenly became aware of a presence within the monitor. His anime was speaking complete english! I saw that he was clicking things on the computer and I feared he would turn off the presence in his monitor. I told him 'Don't touch that! Stop pressing things!' He dismissed my orders and continued to press and click things on the computer. I knew that the anime was originally Japanese, so I was amazed that somehow they were now speaking fluent english to me. I leaned closer to attempt reading the sub-title translations to see if their audible english matched the sub-titles. It wasn't, and they told this to me themselves. They said that they were my only connection to reality and that Friend-A was trying to turn them off.
At this point Friend-A looked at me and was beginning to speak normal sentences to me. Skeptical that it didn't quite fit in with the 'loops' and replied and found that I could communicate with him again. The reality of the loops still felt very real, but I began to realize that I was no longer bound to them. I kept trying to make conversation as to make sure I don't get trapped in the loops again. For a while I just stared at the anime. They were still speaking english, though it was quiet and hard to make out. They were trying to warn me about something. At this point I was now aware that I had smoked salvia. Though it's effects still felt very real, I dismissed them, putting my faith in the fact that I had smoked salvia and just assumed that all I felt to be right would fade and I'd fully regain my normal consciousness again.
-------------
I believe at this point it had been about 6-7 minutes since I smoked the salvia. I am writing this the day after, and I still clearly remember how real it felt. The amazing thing is, while I was on it, everything I was seeing, feeling, etc. was all REAL to me. For me, it brings into question what 'real' actually is. It was no less real than sober reality. So what make's one perspective of reality more right than another.
Salvia is the first and only hallucinogen that I've used to date so I cannot compare the intensity of salvia to anything other drug experiences. I would definitely not recommend the drug to anyone just looking for a good time. The experiences can be very abstract, sometimes scary, and very impressionable. I spend hours thinking and reflecting on my experiences and I'm still in awe of the immense abilities of salvia to effect the mind.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


| GR No | Vendor Bill No | Total Amount | Paid Amount | Due Amount | Paying Amount |
|---|---|---|---|---|---|
| {{selectedLedger.GoodsReceiptPrintId}} | {{selectedLedger.BillNo}} | {{selectedLedger.GRTotalAmount | number}} | {{selectedLedger.DebitAmount | number}} | {{selectedLedger.BalanceAmount | number}} | {{selectedLedger.PayingAmount | number}} |
| Total Payable Amount | {{totalPayableAmount | number}} |
| GR No | Vendor Bill No | Total Amount | Paying Amount | Balance Amount | Status |
|---|---|---|---|---|---|
| {{selectedLedger.GoodsReceiptPrintId}} | {{selectedLedger.BillNo}} | {{selectedLedger.BalanceAmount | number}} | {{selectedLedger.PayingAmount | number}} | {{selectedLedger.BalanceAmount | number}} | {{selectedLedger.Status}} |
NOTE: THIS ACTION IS PERMANENT AND CAN NOT BE REVERTED,PLEASE VERIFY BEFORE TAKING ACTION.


You have assigned this folder to the maximum number of people under the Family Feature. If you wish to assign to more people, please consider LastPass Enterprise.


Prequel quote program
Great program for all prequel memers
How does it work?
Current version: 1.0
This program is very simple. You input a prequel quote (or a part of it) and the program answers with an appropriate response. The program doesn't have any sort of user interface, so it opens in Windows CMD or console.
Currently it features quotes from The Phantom Menace, Attack of the Clones and Revenge of the Sith. In the future I'm planning to add quotes from the likes of Clone Wars, Rogue One, prequel video games etc.
If you have any suggestions or improvements, leave them on this page.
Made by u/YSBjdW50


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| Api2 | Version 2 of the 3Scale API. |
| ApiResponse | |
| HttpConnectionFactory | Interface to obtain an HttpURLConnection. |
| HttpSender | Interface used to send Http Requests to the server. |
| Class Summary | |
|---|---|
| Api2Impl | Concrete implementation of the Version 2 API. |
| ApiFilter | Example Servlet Filter Class for Api access. |
| ApiHttpResponse | Response returned for Http Request. |
| ApiTransaction | Data to be sent for the server for a transaction |
| ApiUsageMetric | DTO for metric data. |
| ApiUtil | Common utility methods. |
| AuthorizeResponse | Response from server containing current statistics. |
| Dates | Utilty class for data formatting. |
| HttpSenderImpl | Concrete implementation of HttpSender |
| Exception Summary | |
|---|---|
| ApiException | Encapsulate Api Exceptions |
This is the version2 API for the 3scale backend. It is used to encapsulate the communication with the 3scale backend server for validating and reporting transactions between the user and the provider of a service.
The version 2 api include caching of authorize operations and batching of responses sent to the server.
For the definitive specification of the interface refer to The 3scale Management API specification
In the package net.threescale.api.v2 there is an example of how to call the api.
The runtime Api for both version 1 and 2 is in the distribution tarball in dist/threescale-api.jar.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


from __future__ import absolute_import, division, print_function, unicode_literals
import six
import os
import logging
from collections import OrderedDict
import tempfile
from madminer.morphing import Morpher
from madminer.utils.interfaces.hdf5 import save_madminer_settings, load_madminer_settings
from madminer.utils.interfaces.mg_cards import export_param_card, export_reweight_card
from madminer.utils.interfaces.mg import generate_mg_process, prepare_run_mg_pythia, run_mg_pythia, copy_ufo_model
from madminer.utils.various import create_missing_folders, general_init, format_benchmark, make_file_executable
from madminer.utils.various import copy_file
[docs]class MadMiner:
"""
The central class to manage parameter spaces, benchmarks, and the generation of events through MadGraph and
Pythia.
An instance of this class is the starting point of most MadMiner applications. It is typically used in four steps:
* Defining the parameter space through `MadMiner.add_parameter`
* Defining the benchmarks, i.e. the points at which the squared matrix elements will be evaluated in MadGraph, with
`MadMiner.add_benchmark()` or, if operator morphing is used, with `MadMiner.set_benchmarks_from_morphing()`
* Saving this setup with `MadMiner.save()` (it can be loaded in a new instance with `MadMiner.load()`)
* Running MadGraph and Pythia with the appropriate settings with `MadMiner.run()` or `MadMiner.run_multiple()` (the
latter allows the user to combine runs from multiple run cards and sampling points)
Please see the tutorial for a hands-on introduction to its methods.
Parameters
----------
debug : bool, optional
If True, additional detailed debugging output is printed. Default value: False.
"""
def __init__(self, debug=False):
general_init(debug=debug)
self.parameters = OrderedDict()
self.benchmarks = OrderedDict()
self.default_benchmark = None
self.morpher = None
self.export_morphing = False
[docs] def add_parameter(
self,
lha_block,
lha_id,
parameter_name=None,
param_card_transform=None,
morphing_max_power=2,
parameter_range=(0.0, 1.0),
):
"""
Adds an individual parameter.
Parameters
----------
lha_block : str
The name of the LHA block as used in the param_card. Case-sensitive.
lha_id : int
The LHA id as used in the param_card.
parameter_name : str or None
An internal name for the parameter. If None, a the default 'benchmark_i' is used.
morphing_max_power : int or tuple of int
The maximal power with which this parameter contributes to the
squared matrix element of the process of interest. If a tuple is given, gives this
maximal power for each of several operator configurations. Typically at tree level,
this maximal number is 2 for parameters that affect one vertex (e.g. only production
or only decay of a particle), and 4 for parameters that affect two vertices (e.g.
production and decay). Default value: 2.
param_card_transform : None or str
Represents a one-parameter function mapping the parameter
(`"theta"`) to the value that should be written in the parameter cards. This
str is parsed by Python's `eval()` function, and `"theta"` is parsed as the
parameter value. Default value: None.
parameter_range : tuple of float
The range of parameter values of primary interest. Only affects the
basis optimization. Default value: (0., 1.).
Returns
-------
None
"""
# Default names
if parameter_name is None:
parameter_name = "parameter_" + str(len(self.parameters))
# Check and sanitize input
assert isinstance(parameter_name, six.string_types), "Parameter name is not a string: {}".format(parameter_name)
assert isinstance(lha_block, six.string_types), "LHA block is not a string: {}".format(lha_block)
assert isinstance(lha_id, int), "LHA id is not an integer: {}".format(lha_id)
parameter_name = parameter_name.replace(" ", "_")
parameter_name = parameter_name.replace("-", "_")
assert parameter_name not in self.parameters, "Parameter name exists already: {}".format(parameter_name)
if isinstance(morphing_max_power, int):
morphing_max_power = (morphing_max_power,)
# Add parameter
self.parameters[parameter_name] = (lha_block, lha_id, morphing_max_power, parameter_range, param_card_transform)
# After manually adding parameters, the morphing information is not accurate anymore
self.morpher = None
logging.info(
"Added parameter %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)",
parameter_name,
lha_block,
lha_id,
morphing_max_power,
parameter_range,
)
[docs] def set_parameters(self, parameters=None):
"""
Manually sets all parameters, overwriting previously added parameters.
Parameters
----------
parameters : dict or list or None, optional
If parameters is None, resets parameters. If parameters is an dict, the keys should be str and give the
parameter names, and the values are tuples of the form (LHA_block, LHA_ID, morphing_max_power, param_min,
param_max) or of the form (LHA_block, LHA_ID). If parameters is a list, the items should be tuples of the
form (LHA_block, LHA_ID). Default value: None.
Returns
-------
None
"""
if parameters is None:
parameters = OrderedDict()
self.parameters = OrderedDict()
if isinstance(parameters, dict):
for key, values in six.iteritems(parameters):
if len(values) == 5:
self.add_parameter(
lha_block=values[0],
lha_id=values[1],
parameter_name=key,
parameter_range=[values[3], values[4]],
morphing_max_power=values[2],
)
elif len(values) == 2:
self.add_parameter(lha_block=values[0], lha_id=values[1], parameter_name=key)
else:
raise ValueError("Parameter properties has unexpected length: {0}".format(values))
else:
for values in parameters:
assert len(values) == 2, "Parameter list entry does not have length 2: {0}".format(values)
self.add_parameter(values[0], values[1])
# After manually adding parameters, the morphing information is not accurate anymore
self.morpher = None
[docs] def add_benchmark(self, parameter_values, benchmark_name=None):
"""
Manually adds an individual benchmark, that is, a parameter point that will be evaluated by MadGraph.
Parameters
----------
parameter_values : dict
The keys of this dict should be the parameter names and the values the corresponding parameter values.
benchmark_name : str or None, optional
Name of benchmark. If None, a default name is used. Default value: None.
Returns
-------
None
Raises
------
RuntimeError
If a benchmark with the same name already exists, if parameter_values is not a dict, or if a key of
parameter_values does not correspond to a defined parameter.
"""
# Default names
if benchmark_name is None:
benchmark_name = "benchmark_" + str(len(self.benchmarks))
# Check input
if not isinstance(parameter_values, dict):
raise RuntimeError("Parameter values are not a dict: {}".format(parameter_values))
for key, value in six.iteritems(parameter_values):
if key not in self.parameters:
raise RuntimeError("Unknown parameter: {0}".format(key))
if benchmark_name in self.benchmarks:
raise RuntimeError("Benchmark name {} exists already".format(benchmark_name))
# Add benchmark
self.benchmarks[benchmark_name] = parameter_values
# If first benchmark, this will be the default for sampling
if len(self.benchmarks) == 1:
self.default_benchmark = benchmark_name
# After manually adding benchmarks, the morphing information is not accurate anymore
self.morpher = None
logging.info("Added benchmark %s: %s)", benchmark_name, format_benchmark(parameter_values))
[docs] def set_benchmarks(self, benchmarks=None):
"""
Manually sets all benchmarks, that is, parameter points that will be evaluated by MadGraph. Calling this
function overwrites all previously defined benchmarks.
Parameters
----------
benchmarks : dict or list or None, optional
Specifies all benchmarks. If None, all benchmarks are reset. If dict, the keys are the benchmark names and
the values are dicts of the form {parameter_name:value}. If list, the entries are dicts
{parameter_name:value} (and the benchmark names are chosen automatically). Default value: None.
Returns
-------
None
"""
if benchmarks is None:
benchmarks = OrderedDict()
self.benchmarks = OrderedDict()
self.default_benchmark = None
if isinstance(benchmarks, dict):
for name, values in six.iteritems(benchmarks):
self.add_benchmark(values, name)
else:
for values in benchmarks:
self.add_benchmark(values)
# After manually adding benchmarks, the morphing information is not accurate anymore
self.morpher = None
[docs] def set_benchmarks_from_morphing(
self, max_overall_power=4, n_bases=1, keep_existing_benchmarks=True, n_trials=100, n_test_thetas=100
):
"""
Sets benchmarks, i.e. parameter points that will be evaluated by MadGraph, for a morphing algorithm, and
calculates all information required for morphing. Morphing is a technique that allows MadMax to infer the full
probability distribution `p(x_i | theta)` for each simulated event `x_i` and any `theta`, not just the
benchmarks.
The morphing basis is optimized with respect to the expected mean squared morphing weights over the parameter
region of interest. If keep_existing_benchmarks=True, benchmarks defined previously will be incorporated in the
morphing basis and only the remaining basis points will be optimized.
Note that any subsequent call to `set_benchmarks` or `add_benchmark` will overwrite the morphing setup. The
correct order is therefore to manually define benchmarks first, using `set_benchmarks` or `add_benchmark`, and
then to create the morphing setup and complete the basis by calling
`set_benchmarks_from_morphing(keep_existing_benchmarks=True)`.
Parameters
----------
max_overall_power : int or tuple of int, optional
The maximal sum of powers of all parameters contributing to the squared matrix element. If a tuple is given,
gives the maximal sum of powers for each of several operator configurations (see `add_parameter`).
Typically, if parameters can affect the couplings at n vertices, this number is 2n. Default value: 4.
n_bases : int, optional
The number of morphing bases generated. If n_bases > 1, multiple bases are combined, and the
weights for each basis are reduced by a factor 1 / n_bases. Currently only the default choice of 1 is
fully implemented. Do not use any other value for now. Default value: 1.
keep_existing_benchmarks : bool, optional
If True, the previously defined benchmarks are included in the basis. In that case, the number of free
parameters in the optimization routine is reduced. If False, all benchmarks are optimized and all previously
defined benchmarks forgotten. Default value: True.
n_trials : int, optional
Number of random basis configurations tested in the optimization procedure. A larger number will increase
the run time of the optimization, but lead to better results. Default value: 100.
n_test_thetas : int, optional
Number of random parameter points used to evaluate the expected mean squared morphing weights. A larger
number will increase the run time of the optimization, but lead to better results. Default value: 100.
Returns
-------
None
"""
logging.info("Optimizing basis for morphing")
if isinstance(max_overall_power, int):
max_overall_power = (max_overall_power,)
morpher = Morpher(parameters_from_madminer=self.parameters)
morpher.find_components(max_overall_power)
if keep_existing_benchmarks:
basis = morpher.optimize_basis(
n_bases=n_bases,
fixed_benchmarks_from_madminer=self.benchmarks,
n_trials=n_trials,
n_test_thetas=n_test_thetas,
)
else:
basis = morpher.optimize_basis(
n_bases=n_bases, fixed_benchmarks_from_madminer=None, n_trials=n_trials, n_test_thetas=n_test_thetas
)
self.set_benchmarks(basis)
self.morpher = morpher
self.export_morphing = True
[docs] def load(self, filename, disable_morphing=False):
"""
Loads MadMiner setup from a file. All parameters, benchmarks, and morphing settings are overwritten. See `save`
for more details.
Parameters
----------
filename : str
Path to the MadMiner file.
disable_morphing : bool, optional
If True, the morphing setup is not loaded from the file. Default value: False.
Returns
-------
None
"""
# Load data
(self.parameters, self.benchmarks, morphing_components, morphing_matrix, _, _) = load_madminer_settings(
filename
)
logging.info("Found %s parameters:", len(self.parameters))
for key, values in six.iteritems(self.parameters):
logging.info(
" %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)",
key,
values[0],
values[1],
values[2],
values[3],
)
logging.info("Found %s benchmarks:", len(self.benchmarks))
for key, values in six.iteritems(self.benchmarks):
logging.info(" %s: %s", key, format_benchmark(values))
if self.default_benchmark is None:
self.default_benchmark = key
# Morphing
self.morpher = None
self.export_morphing = False
if morphing_matrix is not None and morphing_components is not None and not disable_morphing:
self.morpher = Morpher(self.parameters)
self.morpher.set_components(morphing_components)
self.morpher.set_basis(self.benchmarks, morphing_matrix=morphing_matrix)
self.export_morphing = True
logging.info("Found morphing setup with %s components", len(morphing_components))
else:
logging.info("Did not find morphing setup.")
[docs] def save(self, filename):
"""
Saves MadMiner setup into a file.
The file format follows the HDF5 standard. The saved information includes:
* the parameter definitions,
* the benchmark points, and
* the morphing setup (if defined).
This file is an important input to later stages in the analysis chain, including the processing of generated
events, extraction of training samples, and calculation of Fisher information matrices. In these downstream
tasks, additional information will be written to the MadMiner file, including the observations and event
weights.
Parameters
----------
filename : str
Path to the MadMiner file.
Returns
-------
None
"""
create_missing_folders([os.path.dirname(filename)])
if self.morpher is not None:
logging.info("Saving setup (including morphing) to %s", filename)
save_madminer_settings(
filename=filename,
parameters=self.parameters,
benchmarks=self.benchmarks,
morphing_components=self.morpher.components,
morphing_matrix=self.morpher.morphing_matrix,
overwrite_existing_files=True,
)
else:
logging.info("Saving setup (without morphing) to %s", filename)
save_madminer_settings(
filename=filename, parameters=self.parameters, benchmarks=self.benchmarks, overwrite_existing_files=True
)
@staticmethod
def _generate_mg_process(
mg_directory,
temp_directory,
proc_card_file,
mg_process_directory,
ufo_model_directory=None,
log_file=None,
initial_command=None,
):
"""
Calls MadGraph to create the process folder. Instead of this low-level function, it is recommended to use `run`
or `run_multiple`.
Parameters
----------
mg_directory : str
Path to the MadGraph 5 directory.
temp_directory : str
Path to a directory for temporary files.
proc_card_file : str
Path to the process card that tells MadGraph how to generate the process.
mg_process_directory : str
Path to the MG process directory.
ufo_model_directory : str or None, optional
Path to a UFO model that is not yet installed. It will be copied to the MG directory before the process card
is executed. Default value: None.
initial_command : str or None, optional
Initial bash commands that have to be executed before MG is run (e.g. to load the correct virtual
environment). Default value: None.
log_file : str or None, optional
Path to a log file in which the MadGraph output is saved. Default value: None.
Returns
-------
None
"""
logging.info("Generating MadGraph process folder from %s at %s", proc_card_file, mg_process_directory)
create_missing_folders([temp_directory, mg_process_directory, os.path.dirname(log_file)])
if ufo_model_directory is not None:
copy_ufo_model(ufo_model_directory, mg_directory)
generate_mg_process(
mg_directory,
temp_directory,
proc_card_file,
mg_process_directory,
initial_command=initial_command,
log_file=log_file,
)
def _export_cards(
self,
param_card_template_file,
mg_process_directory,
sample_benchmark=None,
param_card_filename=None,
reweight_card_filename=None,
):
"""
Writes out a param_card and reweight_card for MadGraph. Instead of this low-level function, it is recommended to
use `run` or `run_multiple`.
Parameters
----------
param_card_template_file : str
Path to a param_card.dat of the used model.
mg_process_directory : str
Path to the directory of the MG process.
sample_benchmark : str or None, optional
Name of the benchmark used for sampling. If None, the very first defined benchmark is used. Default value:
None.
param_card_filename : str or None, optional
Output filename for the generated param card. If None, a default filename in the MG process folder is used.
Default value: None.
reweight_card_filename : str or None, optional
str or None. Output filename for the generated reweight card. If None, a default filename in the MG process
folder is used. Default value: None.
Returns
-------
None
"""
if param_card_filename is None or reweight_card_filename is None:
logging.info("Creating param and reweight cards in %s", mg_process_directory)
else:
logging.info("Creating param and reweight cards in %s, %s", param_card_filename, reweight_card_filename)
# Check status
assert self.default_benchmark is not None
assert len(self.benchmarks) > 0
# Default benchmark
if sample_benchmark is None:
sample_benchmark = self.default_benchmark
# Export param card
export_param_card(
benchmark=self.benchmarks[sample_benchmark],
parameters=self.parameters,
param_card_template_file=param_card_template_file,
mg_process_directory=mg_process_directory,
param_card_filename=param_card_filename,
)
# Export reweight card
export_reweight_card(
sample_benchmark=sample_benchmark,
benchmarks=self.benchmarks,
parameters=self.parameters,
mg_process_directory=mg_process_directory,
reweight_card_filename=reweight_card_filename,
)
@staticmethod
def _run_mg_and_pythia(
mg_directory,
mg_process_directory,
proc_card_filename=None,
run_card_file=None,
param_card_file=None,
reweight_card_file=None,
pythia8_card_file=None,
is_background=False,
initial_command=None,
log_file=None,
):
"""
Calls MadGraph to generate events. Instead of this low-level function, it is recommended to use `run` or
`run_multiple`.
Parameters
----------
mg_directory : str
Path to the MadGraph 5 base directory.
mg_process_directory : str
Path to the MG process directory.
proc_card_filename : str or None, optional
Filename for the MG command card that will be generated. If None, a default filename in the MG process
directory will be chosen.
run_card_file : str or None, optional
Path to the MadGraph run card. If None, the card present in the process folder is used. Default value:
None)
param_card_file : str or None, optional
Path to the MadGraph run card. If None, the card present in the process folder is used. Default value:
None)
reweight_card_file : str or None, optional
Path to the MadGraph reweight card. If None, the card present in the process folder is used. (Default value
= None)
pythia8_card_file : str or None, optional
Path to the MadGraph Pythia8 card. If None, Pythia is not run. Default value: None.
is_background : bool, optional
Should be True for background processes, i.e. process in which the differential cross section does not
depend on the parameters (and would be the same for all benchmarks). In this case, no reweighting is run,
which can substantially speed up the event generation.
Default value: None.
log_file : str or None, optional
Path to a log file in which the MadGraph output is saved. Default value: None.
Returns
-------
None
"""
# Preparations
create_missing_folders([mg_process_directory, os.path.dirname(log_file)])
if proc_card_filename is not None:
create_missing_folders([os.path.dirname(proc_card_filename)])
# Just run it already
logging.info("Starting MadGraph and Pythia in %s", mg_process_directory)
run_mg_pythia(
mg_directory,
mg_process_directory,
proc_card_filename,
run_card_file,
param_card_file,
reweight_card_file,
pythia8_card_file,
is_background=is_background,
initial_command=initial_command,
log_file=log_file,
)
@staticmethod
def _prepare_mg_and_pythia(
mg_process_directory,
proc_card_filename_from_mgprocdir=None,
run_card_file_from_mgprocdir=None,
param_card_file_from_mgprocdir=None,
reweight_card_file_from_mgprocdir=None,
pythia8_card_file_from_mgprocdir=None,
is_background=False,
script_file_from_mgprocdir=None,
initial_command=None,
log_dir=None,
log_file_from_logdir=None,
):
"""
Prepares a bash script that will start the event generation. Instead of this low-level function, it is
recommended to use `run` or `run_multiple`.
Parameters
----------
mg_process_directory : str
Path to the MG process directory.
proc_card_filename_from_mgprocdir : str or None, optional
Filename for the MG command card that will be generated, relative from mg_process_directory. If None, a
default filename in the MG process directory will be chosen.
param_card_file_from_mgprocdir : str or None, optional
Path to the MadGraph run card, relative from mg_process_directory. If None, the card present in the process
folder is used. Default value: None.
param_card_file_from_mgprocdir : str or None, optional
Path to the MadGraph run card, relative from mg_process_directory. If None, the card present in the process
folder is used. Default value: None.
reweight_card_file_from_mgprocdir : str or None, optional
Path to the MadGraph reweight card, relative from mg_process_directory. If None, the card present in the
process folder is used. Default value: None.
pythia8_card_file_from_mgprocdir : str or None, optional
Path to the MadGraph Pythia8 card, relative from mg_process_directory. If None, Pythia is not run. Default
value: None.
is_background : bool, optional
Should be True for background processes, i.e. process in which the differential cross section does not
depend on the parameters (and would be the same for all benchmarks). In this case, no reweighting is run,
which can substantially speed up the event generation. Default value: False.
script_file_from_mgprocdir : str or None, optional
This sets where the shell script to run MG and Pythia is generated, relative from mg_process_directory. If
None, a default filename in `mg_process_directory/madminer` is used.
Default value: None.
log_file_from_logdir : str or None, optional
Path to a log file in which the MadGraph output is saved, relative from the default log directory. Default
value: None.
Returns
-------
bash_script_call : str
How to call this script.
"""
# Preparations
create_missing_folders([mg_process_directory, log_dir])
if proc_card_filename_from_mgprocdir is not None:
create_missing_folders([os.path.dirname(mg_process_directory + "/" + proc_card_filename_from_mgprocdir)])
# Prepare run...
logging.info("Preparing script to run MadGraph and Pythia in %s", mg_process_directory)
return prepare_run_mg_pythia(
mg_process_directory,
proc_card_filename_from_mgprocdir=proc_card_filename_from_mgprocdir,
run_card_file_from_mgprocdir=run_card_file_from_mgprocdir,
param_card_file_from_mgprocdir=param_card_file_from_mgprocdir,
reweight_card_file_from_mgprocdir=reweight_card_file_from_mgprocdir,
pythia8_card_file_from_mgprocdir=pythia8_card_file_from_mgprocdir,
is_background=is_background,
script_file_from_mgprocdir=script_file_from_mgprocdir,
initial_command=initial_command,
log_file_from_logdir=log_file_from_logdir,
)
[docs] def run(
self,
mg_directory,
proc_card_file,
param_card_template_file,
run_card_file=None,
mg_process_directory=None,
pythia8_card_file=None,
sample_benchmark=None,
is_background=False,
only_prepare_script=False,
ufo_model_directory=None,
log_directory=None,
temp_directory=None,
initial_command=None,
):
"""
High-level function that creates the the MadGraph process, all required cards, and prepares or runs the event
generation for one combination of cards.
If `only_prepare_scripts=True`, the event generation is not run
directly, but a bash script is created in `<process_folder>/madminer/run.sh` that will start the event
generation with the correct settings.
High-level function that creates the the MadGraph process, all required cards, and prepares or runs the event
generation for multiple combinations of run_cards or importance samplings (`sample_benchmarks`).
If `only_prepare_scripts=True`, the event generation is not run
directly, but a bash script is created in `<process_folder>/madminer/run.sh` that will start the event
generation with the correct settings.
Parameters
----------
mg_directory : str
Path to the MadGraph 5 base directory.
proc_card_file : str
Path to the process card that tells MadGraph how to generate the process.
param_card_template_file : str
Path to a param card that will be used as template to create the
appropriate param cards for these runs.
run_card_file : str
Paths to the MadGraph run card. If None, the default run_card is used.
mg_process_directory : str or None, optional
Path to the MG process directory. If None, MadMiner uses ./MG_process. Default value: None.
pythia8_card_file : str or None, optional
Path to the MadGraph Pythia8 card. If None, the card present in the process folder is used.
Default value: None.
sample_benchmark : list of str or None, optional
Lists the names of benchmarks that should be used to sample events. A different sampling does not change
the expected differential cross sections, but will change which regions of phase space have many events
(small variance) or few events (high variance). If None, the benchmark added first is used. Default value:
None.
is_background : bool, optional
Should be True for background processes, i.e. process in which the differential cross section does not
depend on the parameters (i.e. is the same for all benchmarks). In this case, no reweighting is run, which
can substantially speed up the event generation. Default value: False.
only_prepare_script : bool, optional
If True, the event generation is not started, but instead a run.sh script is created in the process
directory. Default value: False.
only_prepare_script : bool, optional
If True, MadGraph is not executed, but instead a run.sh script is created in
the process directory. Default value: False.
ufo_model_directory : str or None, optional
Path to an UFO model directory that should be used, but is not yet installed in mg_directory/models. The
model will be copied to the MadGraph model directory before the process directory is generated. (Default
value = None.
log_directory : str or None, optional
Directory for log files with the MadGraph output. If None, ./logs is used. Default value: None.
temp_directory : str or None, optional
Path to a temporary directory. If None, a system default is used.
Default value: None.
Returns
-------
None
"""
if sample_benchmark is None:
sample_benchmark = self.default_benchmark
self.run_multiple(
mg_directory=mg_directory,
proc_card_file=proc_card_file,
param_card_template_file=param_card_template_file,
run_card_files=[run_card_file],
mg_process_directory=mg_process_directory,
pythia8_card_file=pythia8_card_file,
sample_benchmarks=[sample_benchmark],
is_background=is_background,
only_prepare_script=only_prepare_script,
ufo_model_directory=ufo_model_directory,
log_directory=log_directory,
temp_directory=temp_directory,
initial_command=initial_command,
)
[docs] def run_multiple(
self,
mg_directory,
proc_card_file,
param_card_template_file,
run_card_files,
mg_process_directory=None,
pythia8_card_file=None,
sample_benchmarks=None,
is_background=False,
only_prepare_script=False,
ufo_model_directory=None,
log_directory=None,
temp_directory=None,
initial_command=None,
):
"""
High-level function that creates the the MadGraph process, all required cards, and prepares or runs the event
generation for multiple combinations of run_cards or importance samplings (`sample_benchmarks`).
If `only_prepare_scripts=True`, the event generation is not run
directly, but a bash script is created in `<process_folder>/madminer/run.sh` that will start the event
generation with the correct settings.
Parameters
----------
mg_directory : str
Path to the MadGraph 5 base directory.
proc_card_file : str
Path to the process card that tells MadGraph how to generate the process.
param_card_template_file : str
Path to a param card that will be used as template to create the appropriate param cards for these runs.
run_card_files : list of str
Paths to the MadGraph run card.
mg_process_directory : str or None, optional
Path to the MG process directory. If None, MadMiner uses ./MG_process. Default value: None.
pythia8_card_file : str, optional
Path to the MadGraph Pythia8 card. If None, the card present in the process folder
is used. Default value: None.
sample_benchmarks : list of str or None, optional
Lists the names of benchmarks that should be used to sample events. A different sampling does not change
the expected differential cross sections, but will change which regions of phase space have many events
(small variance) or few events (high variance). If None, a run is started for each of the benchmarks, which
should map out all regions of phase space well. Default value: None.
is_background : bool, optional
Should be True for background processes, i.e. process in which the differential cross section does not
depend on the parameters (i.e. is the same for all benchmarks). In this case, no reweighting is run, which
can substantially speed up the event generation. Default value: False.
only_prepare_script : bool, optional
If True, the event generation is not started, but instead a run.sh script is created in the process
directory. Default value: False.
only_prepare_script : bool, optional
If True, MadGraph is not executed, but instead a run.sh script is created in
the process directory. Default value: False.
ufo_model_directory : str or None, optional
Path to an UFO model directory that should be used, but is not yet installed in mg_directory/models. The
model will be copied to the MadGraph model directory before the process directory is generated. (Default
value = None)
log_directory : str or None, optional
Directory for log files with the MadGraph output. If None, ./logs is used. Default value: None.
temp_directory : str or None, optional
Path to a temporary directory. If None, a system default is used.
Default value: None.
Returns
-------
None
"""
# Defaults
if mg_process_directory is None:
mg_process_directory = "./MG_process"
if temp_directory is None:
temp_directory = tempfile.gettempdir()
if log_directory is None:
log_directory = "./logs"
if sample_benchmarks is None:
sample_benchmarks = [benchmark for benchmark in self.benchmarks]
# Generate process folder
log_file_generate = log_directory + "/generate.log"
self._generate_mg_process(
mg_directory,
temp_directory,
proc_card_file,
mg_process_directory,
ufo_model_directory=ufo_model_directory,
initial_command=initial_command,
log_file=log_file_generate,
)
# Make MadMiner folders
create_missing_folders(
[
mg_process_directory + "/madminer",
mg_process_directory + "/madminer/cards",
mg_process_directory + "/madminer/scripts",
]
)
# Loop over settings
i = 0
results = []
for run_card_file in run_card_files:
for sample_benchmark in sample_benchmarks:
# Files
script_file = "madminer/scripts/run_{}.sh".format(i)
log_file_run = "run_{}.log".format(i)
mg_commands_filename = "/madminer/cards/mg_commands_{}.dat".format(i)
param_card_file = "/madminer/cards/param_card_{}.dat".format(i)
reweight_card_file = "/madminer/cards/reweight_card_{}.dat".format(i)
new_pythia8_card_file = None
if pythia8_card_file is not None:
new_pythia8_card_file = "/madminer/cards/pythia8_card_{}.dat".format(i)
new_run_card_file = None
if run_card_file is not None:
new_run_card_file = "/madminer/cards/run_card_{}.dat".format(i)
logging.info("Run %s", i)
logging.info(" Sampling from benchmark: %s", sample_benchmark)
logging.info(" Original run card: %s", run_card_file)
logging.info(" Original Pythia8 card: %s", pythia8_card_file)
logging.info(" Copied run card: %s", new_run_card_file)
logging.info(" Copied Pythia8 card: %s", new_pythia8_card_file)
logging.info(" Param card: %s", param_card_file)
logging.info(" Reweight card: %s", reweight_card_file)
logging.info(" Log file: %s", log_file_run)
# Creat param and reweight cards
self._export_cards(
param_card_template_file,
mg_process_directory,
sample_benchmark=sample_benchmark,
param_card_filename=mg_process_directory + "/" + param_card_file,
reweight_card_filename=mg_process_directory + "/" + reweight_card_file,
)
# Copy run and Pythia cards
if run_card_file is not None:
copy_file(run_card_file, mg_process_directory + "/" + new_run_card_file)
if pythia8_card_file is not None:
copy_file(pythia8_card_file, mg_process_directory + "/" + new_pythia8_card_file)
# Run MG and Pythia
if only_prepare_script:
result = self._prepare_mg_and_pythia(
mg_process_directory,
proc_card_filename_from_mgprocdir=mg_commands_filename,
run_card_file_from_mgprocdir=new_run_card_file,
param_card_file_from_mgprocdir=param_card_file,
reweight_card_file_from_mgprocdir=reweight_card_file,
pythia8_card_file_from_mgprocdir=new_pythia8_card_file,
is_background=is_background,
script_file_from_mgprocdir=script_file,
initial_command=initial_command,
log_dir=log_directory,
log_file_from_logdir=log_file_run,
)
results.append(result)
else:
self._run_mg_and_pythia(
mg_directory,
mg_process_directory,
mg_process_directory + "/" + mg_commands_filename,
mg_process_directory + "/" + new_run_card_file,
mg_process_directory + "/" + param_card_file,
mg_process_directory + "/" + reweight_card_file,
None if new_pythia8_card_file is None else mg_process_directory + "/" + new_pythia8_card_file,
# mg_process_directory + "/" + new_pythia8_card_file,
is_background=is_background,
initial_command=initial_command,
log_file=log_directory + "/" + log_file_run,
)
i += 1
# Master shell script
if only_prepare_script:
master_script_filename = "{}/madminer/run.sh".format(mg_process_directory)
placeholder_definition = r"mgdir=${1:-" + mg_directory + r"}" + "\n"
placeholder_definition += r"mgprocdir=${2:-" + mg_process_directory + r"}" + "\n"
placeholder_definition += r"mmlogdir=${3:-" + log_directory + r"}"
commands = "\n".join(results)
script = (
"#!/bin/bash\n\n# Master script to generate events for MadMiner\n\n"
+ "# Usage: run.sh [MG_directory] [MG_process_directory] [log_directory]\n\n"
+ "{}\n\n{}"
).format(placeholder_definition, commands)
with open(master_script_filename, "w") as file:
file.write(script)
make_file_executable(master_script_filename)
logging.info(
"To generate events, please run:\n\n %s [MG_directory] [MG_process_directory] [log_dir]\n\n",
master_script_filename,
)


Hit up Harvey Norman Factory Outlet for pre-Black Friday deals
by Elaine LeeBeat the crowd and shop at the Harvey Norman Factory Outlet from tomorrow till Nov 27 for the best pre-Black Friday deals.
Electrical, computer, furniture and bedding deals are up for grabs at the Australian retail chain's outlet store at Viva Business Park, 750B Chai Chee Road.
Shoppers who want to refresh their home appliances and furniture before 2020 arrives can save more than 50 per cent when they buy an LG 55-inch Smart 4K/UHD LED TV (limited sets) at $995 (usual price $3,588), Electrolux Fridge for $526 (usual price $1,099) or Nolan Sofa Bed at $168 (usual price $538).
In addition, get the Dyson V10 Fluffy Handstick Vacuum (limited sets) at $799 (usual price $899) and receive a free $170 Harvey Norman voucher, or grab the Aztech Wifi Mesh System (Twin Pack) at $154 (usual price $249).
For those travelling at the end of the year, raise your travel photography game with the GoPro Action Cam Bundle (limited sets) that comes with a Hero7 Black, Shorty, battery and a 32GB Micro SD Card at $499 (usual price $595).
Save on a branded thin and light notebook at $1,339 (usual price $1,449) or Saisho Groovy Pro True Wireless Earbuds at $49 (usual price $79), while stocks last.
Even better, 0 per cent interest instalment payment plans are available with minimum spend of $500 charged to major banks' credit cards.
Free shuttle buses are available from Bedok, Pasir Ris and Tampines MRT stations to the Harvey Norman Factory Outlet, from 7am to 7.30pm on weekdays and 10am to 8.30pm on weekends and public holidays.
The sale items consist of current models sourced through an exclusive one-off bulk buy for the factory outlet, a global bulk buy due to Harvey Norman's presence in several countries with more than 260 stores, discontinued models, overstocked and clearance models, dented or refurbished items and display sets.


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.
EDM Environmental Design & Mgmt Limited
Mailing Address:
200-2085 Maitland StHALIFAX, Nova Scotia
B3K 2Z8
Location Address:
200-2085 Maitland StHALIFAX, Nova Scotia
B3K 2Z8
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Company Profile
EDM Environmental Design and Management Limited is a planning,
design and engineering firm that provides cost effective and
sustainable solutions to problems related to the human use of
land. The firm uses GIS as a tool to help produce planning and
design solutions for clients in the same way that many design
firms use CAD systems. The process typically involves a detailed
assessment of a planning or design issue, and the identification
of key variables that can be modelled in order to provide the
client with an appropriate solution. A GIS database is then
constructed based on existing data and new data collected by
third parties under EDM's direction (e.g., ecosystem
classifications, eater quality data, etc.) EDM understands that
the cost associated with building a database can take a large
portion of any project budget. All too often data are collected
because they are available, not because they influence the final
planning or design decision. This results in an inefficient use
of resources, ultimately increasing the project's cost and time
schedule.
Once the database has been built, the firm then uses cartographic
modelling techniques to develop suitability maps. These
suitability maps rank areas that are appropriate for development
and or preservation and are used to inform the physical planning
or design process. This provides a scientifically defensible
basis for the resulting plans, which are typically more cost
effective to build or implement, and result in less impact to the
environment.
The following examples provide an indication of the firm's work,
and demonstrate its ability to apply the methodology at a variety
of project scales (i.e., both large and small projects):
-Watershed Management Plan for Gander Lake. EDM developed a GIS
based cartographic model that predicts sediment production in a
1,500 sq. Kilometre catchment by land use, and calibrated the
model to suspended solids and phosphorous concentrations in the
lake water. This model will be used by planners to assess the
impact of various development proposal and land use plans.
-Planning Strategy for North Dartmouth. A land use plan we
prepared for 1,700 acres of undeveloped land adjacent to the
largest industrial park in Nova Scotia. The client wanted to
know where the industrial park could be expanded, while at the
same time preserving the environment and keeping site
development cost to a minimum. Suitability maps were generated
to illustrate areas appropriate for industrial and residential
development as well as land preservation.
-Kingswood Subdivision Plan. A master plan we prepared for a 200
acre residential subdivision based on a analysis of the land
within a GIS. Suitability maps highlighted areas suitable for
road construction (avoiding bedrock, wetlands, steep slopes,
etc.) As well as areas suitable for on site sewage disposal
(soil permeability, appropriate slope, etc.).
The firm is also a member of the Canada Geomatics Group, a
consortium of four private companies and two government sponsors,
that includes over 250 employees throughout Canada. This
consortium provides EDM with a wide array of resources from which
to draw on in order to provide its clients with a total geomatics
solution. Other member firms include: Hauts-Monts (Quebec);
Triathlon Mapping (British Columbia); GeoNet Technologies (PEI);
New Brunswick Geomatics Information Centre; and, Land Records
Management Inc. (Govt.NS). For more information please contact
John Heseltine at<PHONE_NUMBER> or<EMAIL_ADDRESS>Full profile
Full profile
Contact information
Company description
541619 - Other Management Consulting Services
541620 - Environmental Consulting Services
Product / Service / Licensing
The approach considers the true value of resources not normally accounted for by economists and engineers acting alone, including ecotourism, water quality, and quality of life. Finding opportunities in what were formerly considered problems, such as using sludge from sewage treatment plants to reclaim or restore nearby abandoned mine sites, is typical of this kind of work.
Community participation techniques are designed to empower communities, including environmental and social values in decision making, as well as the incorporation of proven, scientific methodologies for demonstrating the impact of development on land and water.
Solar Aquatics Systems treats organic waste, which includes sewage, septage and food processing waste. This system is often referred to as the "wetland in a greenhouse". The system provides cost-effective, tertiary level treatment without the use of chemicals, and in a manner which is far more attractive to a community than conventional technology. This is because it is odour free, requires little space, and is aesthetically pleasing.
The Solar Aquatics System is designed to "live" within a greenhouse. Sewage is not treated as a waste, but rather considered as a food for the biological community resident in the greenhouse. The system uses a combination of bacteria, algae, zooplankton, plants, snails and fish to process the wastewater. These contained in a combination of clear sided solar tanks, solar ponds and engineered marshes all housed within a greenhouse. The entire system works in a concerted manner to consume the organic nutrients in the water. This enables the Solar Aquatics System to provide performance equivalent to that of a tertiary treatment plant, without the use of chemicals, and without producing as much residual sludge.
This approach to waste treatment offers a solution which is cost-effective; produces high quality effluent; is capable of dealing with strong organic waste; is self-contained, and therefore can be efficiently used to treat sewage flows from 20,000-500,000 gal./day, a range which satisfies the needs of most small communities or neighbourhoods within large urban areas.
Typical Services
-Ecological Planning Studies
-Water Resource Management Plans
-Terrestrial and Aquatic Site Rehabilitation
-Landfill Siting Studies
-Stormwater Management Strategies and Design
-Erosion and Sediment Control Plans
-Environmental Audits and Impact Assessments
-Visual Impact Assessment
-Community Servicing Strategies and Design
-On-Site Sewage System Capability Studies
-Wastewater Management District Implementation
-Biosolids Management Plans
-Wildlife and Habitat Protection and Enhancement Plans
-Computer Modelling/Simulation and 3-D Computer Modelling
-Environmental Protection Planning Strategies for Communities
-Community Consultation
DESCRIPTION
EDM is a firm that specializes in developing plans and strategies
for both sustainable development and environmental protection.
The essence of Environmental Planning is the informed acquisition
and interpretation of information about the environment, and then
development of a plan of action based upon that information.
EDM specializes in managing these complex planning challenges.
The firm's integration of engineering, science, economic and
planning of professionals allows for comprehensive treatment of
the problems, and the opportunity for truly innovative solutions.
APPROACH
The environmental field is dynamic. New science is available
daily which affects how decisions are made.
EDM's approach to this constant change includes keeping current
with anew developments. Broadening staff project experience;
on-going specialized training and education;' thorough review of
journals; participation in conferences and committees: and,
on-going research are all company policy. We frequently include
world experts as project advisors and always hire sub-consultants
when we are outside our field of expertise. Our clients are
assured that our solutions are as current as possible.
Environmental Planning frequently requires modelling in order to
predict change and make a decision about how to proceed. Most
readily available models were developed for science. These
models are frequently more detailed than necessary to make a
decision and too narrow in scope to effectively deal with a broad
planning problem. EDM specializes in the development and
application of models that are specifically tailored to
environmental planning problems.
Finally, our approach to environmental planning is community
oriented. We understand that a plan or strategy can only be
successful when the users have been consulted throughout the
process.
TYPICAL SERVICES;
-Facility Siting Studies
-Resource Development Planning Studies
-Development Impact Assessment
-Development Suitability Analysis
-Municipal Plan/Zoning Interpretation, Review, and Amendments
-Land Use Plans
-Residential Community Master plans
-Industrial/Business Park Master plans
-Park and Recreation Master plans
-Ecotourism Plans
-Waterfront Development Plans
-Cost Benefit and Decision Analysis of Development Scenarios
-CAD,GIS, Image Capture and 3-D Computer Modelling and Animation
-Community
DESCRIPTION
EDM offers a complete land planning service beneficial to land
owners who need a plan for where, when and how to implement their
development ideas. We also help clients select the appropriate
land for an intended use, such as finding the best site for a
landfill, school, aquaculture site, or highway.
Land planning is a complex undertaking requiring the simultaneous
resolution of economic, technical, regulatory, engineering,
servicing, environmental, and a host of other factors. EDM's mix
of professional staff, our willingness to seek out and include
expert opinion in the process, as well as our emphasis on
creative problem solving, ensures that we excel at finding
"win-win" solutions to these complex problems.
APPROACH
EDM's approach to land planning is established in a strong land
ethic. We believe that it is possible to develop land in an
environmentally responsible manner. This is accomplished by
obtaining a thorough understanding of the relationship between
the built environment and the land. The process begins by
acquiring information about the existing natural environment and
assessing the opportunities and limitations of the land prior to
creating a plan. It has been our experience that this approach
also results in reduced site development costs.
EDM specializes in the development and use of computer models in
support of the planning process. Models range from GIUS
suitability analysis and lake water carrying capacity models, to
3-D project visualization, to model of financial performance.
Our land use plans and Master plans are thus scientifically and
economically defensible and readily understood by both our
clients and the public.
Our staff work as project teams where the objectives of
engineering, landscape, social, environmental, and financial
professionals must be met equally if the plan is to be brought
forward. We offer staff who have been trained by world leaders
in suitability analysis and land planning methods, expertise in
alternative community servicing strategies, as well as a track
record in effective community consultation.
Dredging
Energy From Waste
Audits
Engineering Design Specifications
Environmental Impact Assessments
Equipment Or Instrument Development
Geomatic (GIS) Applications
Mapping of Resources, Land Type
Site Assessment
Site / Land Reclamations
Soil and Ground Water
Systems Modelling or design
Waste Reduction and Recycling
Water Quality
Market profile
Industry sector market interests:
- Agriculture
- Environment
- Forestry
- Manufacturing
- Mining/Petroleum/Gas
- Service Industry
- Tourism
Geographic markets:
Actively pursuing:
- China
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
541619 - Other Management Consulting Services
541620 - Environmental Consulting Services
Products, services and licensing
Product / Service / Licensing
The approach considers the true value of resources not normally accounted for by economists and engineers acting alone, including ecotourism, water quality, and quality of life. Finding opportunities in what were formerly considered problems, such as using sludge from sewage treatment plants to reclaim or restore nearby abandoned mine sites, is typical of this kind of work.
Community participation techniques are designed to empower communities, including environmental and social values in decision making, as well as the incorporation of proven, scientific methodologies for demonstrating the impact of development on land and water.
Solar Aquatics Systems treats organic waste, which includes sewage, septage and food processing waste. This system is often referred to as the "wetland in a greenhouse". The system provides cost-effective, tertiary level treatment without the use of chemicals, and in a manner which is far more attractive to a community than conventional technology. This is because it is odour free, requires little space, and is aesthetically pleasing.
The Solar Aquatics System is designed to "live" within a greenhouse. Sewage is not treated as a waste, but rather considered as a food for the biological community resident in the greenhouse. The system uses a combination of bacteria, algae, zooplankton, plants, snails and fish to process the wastewater. These contained in a combination of clear sided solar tanks, solar ponds and engineered marshes all housed within a greenhouse. The entire system works in a concerted manner to consume the organic nutrients in the water. This enables the Solar Aquatics System to provide performance equivalent to that of a tertiary treatment plant, without the use of chemicals, and without producing as much residual sludge.
This approach to waste treatment offers a solution which is cost-effective; produces high quality effluent; is capable of dealing with strong organic waste; is self-contained, and therefore can be efficiently used to treat sewage flows from 20,000-500,000 gal./day, a range which satisfies the needs of most small communities or neighbourhoods within large urban areas.
Typical Services
-Ecological Planning Studies
-Water Resource Management Plans
-Terrestrial and Aquatic Site Rehabilitation
-Landfill Siting Studies
-Stormwater Management Strategies and Design
-Erosion and Sediment Control Plans
-Environmental Audits and Impact Assessments
-Visual Impact Assessment
-Community Servicing Strategies and Design
-On-Site Sewage System Capability Studies
-Wastewater Management District Implementation
-Biosolids Management Plans
-Wildlife and Habitat Protection and Enhancement Plans
-Computer Modelling/Simulation and 3-D Computer Modelling
-Environmental Protection Planning Strategies for Communities
-Community Consultation
DESCRIPTION
EDM is a firm that specializes in developing plans and strategies
for both sustainable development and environmental protection.
The essence of Environmental Planning is the informed acquisition
and interpretation of information about the environment, and then
development of a plan of action based upon that information.
EDM specializes in managing these complex planning challenges.
The firm's integration of engineering, science, economic and
planning of professionals allows for comprehensive treatment of
the problems, and the opportunity for truly innovative solutions.
APPROACH
The environmental field is dynamic. New science is available
daily which affects how decisions are made.
EDM's approach to this constant change includes keeping current
with anew developments. Broadening staff project experience;
on-going specialized training and education;' thorough review of
journals; participation in conferences and committees: and,
on-going research are all company policy. We frequently include
world experts as project advisors and always hire sub-consultants
when we are outside our field of expertise. Our clients are
assured that our solutions are as current as possible.
Environmental Planning frequently requires modelling in order to
predict change and make a decision about how to proceed. Most
readily available models were developed for science. These
models are frequently more detailed than necessary to make a
decision and too narrow in scope to effectively deal with a broad
planning problem. EDM specializes in the development and
application of models that are specifically tailored to
environmental planning problems.
Finally, our approach to environmental planning is community
oriented. We understand that a plan or strategy can only be
successful when the users have been consulted throughout the
process.
TYPICAL SERVICES;
-Facility Siting Studies
-Resource Development Planning Studies
-Development Impact Assessment
-Development Suitability Analysis
-Municipal Plan/Zoning Interpretation, Review, and Amendments
-Land Use Plans
-Residential Community Master plans
-Industrial/Business Park Master plans
-Park and Recreation Master plans
-Ecotourism Plans
-Waterfront Development Plans
-Cost Benefit and Decision Analysis of Development Scenarios
-CAD,GIS, Image Capture and 3-D Computer Modelling and Animation
-Community
DESCRIPTION
EDM offers a complete land planning service beneficial to land
owners who need a plan for where, when and how to implement their
development ideas. We also help clients select the appropriate
land for an intended use, such as finding the best site for a
landfill, school, aquaculture site, or highway.
Land planning is a complex undertaking requiring the simultaneous
resolution of economic, technical, regulatory, engineering,
servicing, environmental, and a host of other factors. EDM's mix
of professional staff, our willingness to seek out and include
expert opinion in the process, as well as our emphasis on
creative problem solving, ensures that we excel at finding
"win-win" solutions to these complex problems.
APPROACH
EDM's approach to land planning is established in a strong land
ethic. We believe that it is possible to develop land in an
environmentally responsible manner. This is accomplished by
obtaining a thorough understanding of the relationship between
the built environment and the land. The process begins by
acquiring information about the existing natural environment and
assessing the opportunities and limitations of the land prior to
creating a plan. It has been our experience that this approach
also results in reduced site development costs.
EDM specializes in the development and use of computer models in
support of the planning process. Models range from GIUS
suitability analysis and lake water carrying capacity models, to
3-D project visualization, to model of financial performance.
Our land use plans and Master plans are thus scientifically and
economically defensible and readily understood by both our
clients and the public.
Our staff work as project teams where the objectives of
engineering, landscape, social, environmental, and financial
professionals must be met equally if the plan is to be brought
forward. We offer staff who have been trained by world leaders
in suitability analysis and land planning methods, expertise in
alternative community servicing strategies, as well as a track
record in effective community consultation.
Dredging
Energy From Waste
Audits
Engineering Design Specifications
Environmental Impact Assessments
Equipment Or Instrument Development
Geomatic (GIS) Applications
Mapping of Resources, Land Type
Site Assessment
Site / Land Reclamations
Soil and Ground Water
Systems Modelling or design
Waste Reduction and Recycling
Water Quality
Market
Market profile
Industry sector market interests:
- Agriculture
- Environment
- Forestry
- Manufacturing
- Mining/Petroleum/Gas
- Service Industry
- Tourism
Geographic markets:
Actively pursuing:
- China


WELCOME TO SAT
This is the official homepage of SAT. SAT stands for Scholarship Aptitude Test.
Click Here to Register
If already Registered, Click Here
Check your Performance


Welcome to Developer Observatory, a browser-based virtual laboratory platform that enables controlled programming experiments while retaining most of the observational power of lab studies. The Developer Observatory can be used to conduct large-scale, reliable online programming studies with reasonable external validity.
If you are interested in the backgrounds of the tool, you'll be able to find the paper here after the CSET'17 workshop.


Routing Algorithms
- The purpose of routing is to find a good path to get from point A to point B
- Default router/First-hop router: The only router a host is connected to
- Source router/Destination router: The default router of a source/destination
- Routing from a source host to a destination host is about routing the source router to the destination router.
- A good path usually is the path with the least cost.
- However, there are “real-world concerns” such as policy issues that prevent requests from certain companies be denied on other company routers.
- The cost of an edge typically may reflect the physical length, the link speed, or monetary cost. The textbook will just give the cost, so don’t worry about it.
- The cost of edge (x,y) is represented by c(x, y)
- Globalized Routing Algorithm: Each node has information about distance between all nodes.
- Decentralized Routing Algorithm:Each node only has knowledge on the distance between its neighboring nodes.
- Distance Vectoring algorithm


If you are experiencing choppy, stuttering, or broken up playback when viewing HEVC video on your Samsung Galaxy S5 Active, it is probably because your device doesn’t support the new HEVC H.265 codec, or your video has high specifications that your Samsung Galaxy S5 Active cannot handle. If that’s the case, converting the HEVC video to a format that is compatible with your Samsung Galaxy S5 Active would be a workable solution.
The Samsung Galaxy S5 Active is a single SIM (GSM) smartphone that accepts a Micro-SIM. Connectivity options include Wi-Fi, GPS, Bluetooth, NFC, 3G and 4G. Sensors on the phone include Proximity sensor, Accelerometer, Ambient light sensor, Gyroscope and Barometer.
Why convert HEVC/H.265 video for Samsung Galaxy S5 Active?
Depending on hardware, software, video/audio formats/codecs, frame rate, bitrate, file sizes and much more, your device will have different performances playing an HEVC/H.265 video. If you have a high-end device that supports HEVC hardware decoder, you don’t need to do this at all. But if your Samsung Galaxy S5 Active struggles to play HEVC videos, you will need to convert them to a format that is compatible with your Samsung Galaxy S5 Active first. That’s where an HEVC to Samsung Galaxy S5 Active converter comes in. We demonstrate how to process file conversion below:
Part 1:
How to convert hevc videos for Samsung Galaxy S5 Active on Windows?
Part 2:
How to convert hevc videos for Samsung Galaxy S5 Active on Mac?
[pt_view id="2e16a40sux"]
Part 1. How to convert hevc videos for Samsung Galaxy S5 Active on Windows?
To convert hevc videos for Samsung Galaxy S5 Active playback on Windows, do as below:
Step 1: Import video files
Click “Add File” to load video files that you want to convert into this program.
Step 2: Select output format for Samsung Galaxy S5 Active
Click "Profile" to select
"Samsung" > "Samsung Galaxy S5(*.mp4)" as output format. This format profile will ensure a good performance while playing with Galaxy S5 Active.
Tips:
If necessary, you can click "Settings" button to modify video and audio parameters like encoder, resolution, frame rate, bitrate, aspect ratio, sample rate, and audio channels. You can also “Enable 3D Settings” to add 3D effect to your source media.
Step 3: Click “Convert” to start hevc video to Samsung Galaxy S5 Active conversion on Windows.
As soon as the conversion is complete, click “Open Folder” to get the generated
MP4 files that are suitable for playing on your Samsung Galaxy S5 Active. No audio lost issues will occur any more.
Part 2. How to convert hevc videos for Samsung Galaxy S5 Active on Mac?
To convert hevc videos for Samsung Galaxy S5 Active playback on Mac, do as below:
Step 1: Import video files
Click “Add File” to load video files that you want to convert into this program.
Step 2: Select output format for Samsung Galaxy S5 Active
Click "Profile" to select
"Samsung" > "Samsung Galaxy S5(*.mp4)" as output format. This format profile will ensure a good performance while playing with Galaxy S5 Active.
Tips:
If necessary, you can click "Settings" button to modify video and audio parameters like encoder, resolution, frame rate, bitrate, aspect ratio, sample rate, and audio channels. You can also “Enable 3D Settings” to add 3D effect to your source media.
Step 3: Click “Convert” to start hevc video to Samsung Galaxy S5 Active conversion on Mac.
As soon as the conversion is complete, click “Open Folder” to get the generated
MP4 files that are suitable for playing on your Samsung Galaxy S5 Active. No audio lost issues will occur again.
Also read:
Samsung Galaxy Note 8 won’t play HEVC H.265 media, how to fix?


FleetIQ makes abstraction layer Game Server Group for game hosting, and it uses Auto Scaling Group. Game server resources are registered in FleetIQ, and managed in Game Server Group.
When you create a game server group in FleetIQ, an Auto Scaling Group is created, and computing resources to allocate within the Auto Scaling Group are launched. So it’s important to allocate a group of game servers with appropriate instance types to optimize your computing resources. FleetIQ regularly evaluates each Spot instance types in the game server group list based on the prediction algorithm to calculate the feasibility for hosting the game.
Move to IAM console. (https://console.aws.amazon.com/iam/home?)
Click “Role” button on IAM console, and create new Role for EC2 use case.
Attach Permissions policies. If you search “GameLift” as a keyword, you are able to find GameLiftGameServerGroupPolicy. Also if we finish previous lab, you can find GameLiftFullAccess Role. (If not, please refer 1-4 on this lab)
Access to EC2 console (https://console.aws.amazon.com/ec2/v2/home)
Click Start Template in the left menu and create a new start template.
Configure the template as follows.
If you have conducted Windows-based labs before, in this lab, we will configure a Linux-based game server, so choose Amazon Linux2 AMI. This can show you how your architecture can be flexible. The key-pair setting is also performed to enable login.
Choose GameLiftFleetIQRole that we made previously for IAM instance Profile.
Put follow text as user data.
#!/bin/bash
sudo yum install python3 -y
sudo pip3 install boto3
sudo pip3 install requests
sudo yum install -y gcc-c++ make
curl -sL https://rpm.nodesource.com/setup_12.x | sudo -E bash
sudo yum install -y nodejs
The user data code above describes the operation to connect the Cloud9 IDE remotely when the game server is created.
Let’s make Game Server Group. You are able to try this with AWS CLI v2.
aws gamelift create-game-server-group --game-server-group-name GameServerGroups --role-arn <FleetIQFiestaRole ARN> --min-size 1 --max-size 2 --launch-template LaunchTemplateId=<LaunchTemplate ID> --instance-definitions '[{"InstanceType": "c5.large"}, {"InstanceType": "m5.large"}]' --region ap-northeast-2
Please put right information between brackets <>. Also check for region on this command.
If the creation of the game server group is too delayed, it is recommended to check the permissions.
You can also check the auto-created instance in the EC2 console. Those indicate game servers available in the game server group.
However, you can’t use FleetIQ function through the game servers yet. To use FleetIQ function, you must configure FleetIQ Lifecycle.


{% extends 'occupants/base.html' %} {% load staticfiles %} {% block title %}Homepage{% endblock %} {% block body %}
Are you sure that you want to delete this timetable entry?


Some text to help admin to work with the site
The text is in the file ~/resources/views/Admin/Pages/help.htm
Link to About


parataxis
: parataxis
The parataxis
relation holds between a word (usually the head of the main clause) and other elements which are not linked to it by a relation of coordination, subordination, or any other type of core grammatical relation. This relation is typically used for various types of run-on sentences which are presented in more detail below.
The 7parataxis` relation is used for run-on sentences that can be broken up into individual units and are not explicitly separated by any conjunction (apart from punctuation like a comma, semicolon, or colon). The head of the relation is always the first clause in the sequence.
Svetujemo : Bodite pozitivni do sebe in svoje okolice . \n We-advise : Be positive towards yourself and your environment .
parataxis(Svetujemo,pozitivni)
cop(pozitivni,Bodite)
parataxis(We-advise,positive)
cop(positive,Be)
There are currently also three special types of coordination that use the parataxis
relation:
- Coordinate clauses where the linking word—usually marked with the
advmod
relation—occurs in the middle of the clause (and not at the start, as is the case withconj
andcc
).Nekaj ljudi iz te bolnišnice odide drugam , nekaj pa jih pride iz drugih . \n Some people from this hospital go elsewhere , some CONJ of-them come from others . parataxis(odide,pride) parataxis(go,come)
- Asyndetic coordination where several main or subordinate clauses are semantically in coordination, but there is no explicit coordinating conjunction between them.
Prišel , videl , zmagal . \n I-came , I-saw , I-won . parataxis(Prišel,videl) parataxis(Prišel,zmagal) parataxis(I-came,I-saw) parataxis(I-came,I-won)
- Comments that are introduced by pronominal conjunctions such as kar, s čimer, pri čemer which do not refer to any specific item, but to the preceding clause as a whole.
Konec tedna je blagovnica v Cerknici samevala , kar je izkoristil nepridiprav iz bližnje okolice . \n At-the-end of-the-week was the-store in Cerknica empty , which was exploited-by a-ne're-do-well from the-surrounding area . parataxis(samevala,izkoristil) parataxis(empty,exploited-by)
In the case of parenthetical clauses, regardless of the position of the parenthetical clause, the head of the main clause is treated as the head of the relation, while the head of the parenthesis is treated as its dependent.
Glavni žrtvi bova , kaže , prav midva . \n Main victims will-be , it-seems , precisely us .
parataxis(žrtvi,kaže)
cop(žrtvi,bova)
parataxis(victims,it-seems)
cop(victims,will-be)
The parataxis
relation is also used for linking together the reported clause and the reporting clause in reported speech. Regardless of the order in which the reported clause and the reporting clause appear, the head of the relation is always the first clause in the sequence.
Takole se je glasil : " Ali mora kmet res vedno le ubogati ? " \n This REFLEX aux-PAST it-said : " Does have-to a-farmer really always only obey ? "
parataxis(glasil,mora)
parataxis(it-said,have-to)
" To je Victor , " je pojasnil Victor Riccio . \n " This is Victor , " aux-PAST explained Victor Riccio .
parataxis(Victor-4,pojasnil)
parataxis(Victor-16,explained)
" Nimam časa , " sem butasto bleknila , " ker moram na postajo . \n " I-do-not-have time , " aux-PAST stupidly I-said , " because I-have-to-go to station .
parataxis(Nimam,bleknila)
advcl(Nimam,moram)
parataxis(I-do-not-have,I-said)
advcl(I-do-not-have,I-have-to-go)
In addition to linking together clauses, the parataxis
relation is also used for paratactical nominal phrases that do not fit into any other grammatical category, such as in the introductory parts of press articles:
Postojna - Z nedeljskim mitingom so se končali Dnevi vojske \n Postojna - With Sunday's meeting aux-PAST REFLEX ended Days of-the-army
parataxis(končali,Postojna-1)
parataxis(ended,Postojna-12)
Only parenthetical clauses with verbs receive the parataxis
relation. See the discourse relation for more on parenthetical interjections (e.g., Že vidimo, kajne, kako nam Kajn postaja bližji). If an element is set off from the rest of the sentence by some type of punctuation mainly for adding stylistic emphasis—that is to say, it could function just as well within the sentence without the punctuation (for example, Kolikor vem, ima ta beseda, vsaj pri večini ljudi, negativen prizvok or V minulih dveh tednih smo, res ne pretirano javno, pripravljali ukrepe)—then the element is analyzed as an ordinary internal element, not as parataxis
.
parataxis in other languages: [bej] [bg] [bm] [cop] [cs] [de] [el] [en] [es] [fi] [fr] [ga] [gsw] [hy] [it] [ja] [kk] [ky] [no] [pcm] [pt] [qpm] [ru] [sl] [sv] [tr] [u] [yue] [zh]