version

.clang-tidy

@@ -18,8 +18,7 @@ Checks:          '*,
                     -google-readability-todo, 
                     -google-readability-braces-around-statements,
                     -modernize-use-trailing-return-type,
-                    -readability-isolate-declaration,
+                    -readability-isolate-declaration'
-                    -llvmlibc-*'
 
 HeaderFilterRegex: \.h
 AnalyzeTemporaryDtors: false

CMakeLists.txt

@@ -32,16 +32,13 @@ if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     set(SLS_MASTER_PROJECT ON)
 endif()
 
-option(SLS_USE_HDF5 "HDF5 File format" OFF)
+option (SLS_USE_HDF5 "HDF5 File format" OFF)
-option(SLS_BUILD_SHARED_LIBRARIES "Build shared libaries" ON)
+option (SLS_USE_TEXTCLIENT "Text Client" ON)
-option(SLS_USE_TEXTCLIENT "Text Client" ON)
+option (SLS_USE_RECEIVER "Receiver" ON)
-option(SLS_USE_DETECTOR "Detector libs" ON)
+option (SLS_USE_GUI "GUI" OFF)
-option(SLS_USE_RECEIVER "Receiver" ON)
+option (SLS_USE_SIMULATOR "Simulator" OFF)
-option(SLS_USE_RECEIVER_BINARIES "Receiver binaries" ON)
+option (SLS_USE_TESTS "TESTS" OFF)
-option(SLS_USE_GUI "GUI" OFF)
+option (SLS_USE_INTEGRATION_TESTS "Integration Tests" OFF)
-option(SLS_USE_SIMULATOR "Simulator" OFF)
-option(SLS_USE_TESTS "TESTS" OFF)
-option(SLS_USE_INTEGRATION_TESTS "Integration Tests" OFF)
 option(SLS_USE_SANITIZER "Sanitizers for debugging" OFF)
 option(SLS_USE_PYTHON "Python bindings" OFF)
 option(SLS_USE_CTBGUI "ctb GUI" OFF)
@@ -96,20 +93,6 @@ target_compile_options(slsProjectWarnings INTERFACE
 
                                  )
 
-#Settings for C code
-add_library(slsProjectCSettings INTERFACE)
-target_compile_features(slsProjectCSettings INTERFACE c_std_99)
-target_compile_options(slsProjectCSettings INTERFACE 
-                                            -Wall
-                                            -Wextra
-                                            -Wno-unused-parameter
-                                            -Wdouble-promotion
-                                            -Wformat=2
-                                            -Wredundant-decls
-                                            -Wdouble-promotion
-                                            -Werror=return-type
-                                )
-
 
 #Testing for minimum version for compilers
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -174,37 +157,8 @@ set(CMAKE_INSTALL_RPATH $ORIGIN)
 set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 
 
-set(ZeroMQ_HINT "" CACHE STRING "Hint where ZeroMQ could be found")
-#Adapted from: https://github.com/zeromq/cppzmq/
-if (NOT TARGET libzmq)
-    if(ZeroMQ_HINT)
-        message(STATUS "Looking for ZeroMQ in: ${ZeroMQ_HINT}")
-        find_package(ZeroMQ 4 
-            NO_DEFAULT_PATH
-            HINTS ${ZeroMQ_DIR}
-        )
-    else()
-        find_package(ZeroMQ 4 QUIET)
-    endif()
-    
 
-
+find_package(ZeroMQ 4 REQUIRED)
-  # libzmq autotools install: fallback to pkg-config
-  if(NOT ZeroMQ_FOUND)
-    message(STATUS "CMake libzmq package not found, trying again with pkg-config (normal install of zeromq)")
-    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
-    find_package(ZeroMQ 4 REQUIRED)
-  endif()
-
-  # TODO "REQUIRED" above should already cause a fatal failure if not found, but this doesn't seem to work
-  if(NOT ZeroMQ_FOUND)
-    message(FATAL_ERROR "ZeroMQ was not found, neither as a CMake package nor via pkg-config")
-  endif()
-
-  if (ZeroMQ_FOUND AND NOT TARGET libzmq)
-    message(FATAL_ERROR "ZeroMQ version not supported!")
-  endif()
-endif()
 
 if (SLS_USE_TESTS)
     enable_testing()
@@ -217,9 +171,9 @@ endif(SLS_USE_TESTS)
 # Common functionallity to detector and receiver
 add_subdirectory(slsSupportLib)
 
-if (SLS_USE_DETECTOR OR SLS_USE_TEXTCLIENT)
+if (SLS_USE_TEXTCLIENT)
     add_subdirectory(slsDetectorSoftware)
-endif ()
+endif (SLS_USE_TEXTCLIENT)
 
 if (SLS_USE_RECEIVER)
     add_subdirectory(slsReceiverSoftware) 

LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

LICENSE.lesser

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

README.md

@@ -4,11 +4,7 @@ Please do not update to any xxxx.xx.xx.dev0 tags. They are not releases, but tag
 Use only releases with tags such as x.x.x or x.x.x-rcx.
 
 ### Documentation
-##### 5.0.0 - Latest Release
+Detailed documentation on the latest release of 5.0.0 can be found in the [software wiki](https://slsdetectorgroup.github.io/devdoc/index.html) and on the [official site](https://www.psi.ch/en/detectors/software).
-Detailed documentation on the latest release can be found in the [software wiki](https://slsdetectorgroup.github.io/devdoc/index.html) and on the [official site](https://www.psi.ch/en/detectors/software).
-
-##### Older Releases
-Documentation is found in the package.
 
 ### Binaries
 Binaries for the slsDetectorPackage are available through conda. 
@@ -49,7 +45,7 @@ These are mainly aimed at those not familiar with using ccmake and cmake.
 ```
     The binaries are generated in slsDetectorPackage/build/bin directory.
 
-    Usage: ./cmk.sh [-c] [-b] [-p] [e] [t] [r] [g] [s] [u] [i] [m] [n] [-h] [z] [-d <HDF5 directory>] [-l Install directory] [-k <CMake command>] [-j <Number of threads>]
+    Usage: $0 [-c] [-b] [-p] [e] [t] [r] [g] [s] [u] [i] [m] [n] [-h] [z] [-d <HDF5 directory>] [-l Install directory] [-k <CMake command>] [-j <Number of threads>]
     -[no option]: only make
     -c: Clean
     -b: Builds/Rebuilds CMake files normal mode
@@ -69,7 +65,6 @@ These are mainly aimed at those not familiar with using ccmake and cmake.
     -m: Manuals
     -n: Manuals without compiling doxygen (only rst)
     -z: Moench zmq processor
-
     
     # get all options
     ./cmk.sh -?
@@ -95,8 +90,3 @@ To install binaries using CMake
     make -j12 #or whatever number of cores you are using to build
     make install
 ```
-
-
-### Support
-    dhanya.thattil@psi.ch
-    erik.frojdh@psi.ch

RELEASE.txt

@@ -1,13 +1,14 @@
-SLS Detector Package 6.0.0-rc1 released on 08.10.2021 (Release Candidate 1)
+SLS Detector Package 5.1.0 released on xx.xx.2020 (Minor Release)
-===========================================================================
+===================================================================
 
-This document describes the differences between v6.0.0-rc1 and v5.1.0.   
+This document describes the differences between 5.1.0 and 5.x.x releases.   
 
 
 
     CONTENTS
     --------
-    1.  New or Changed Features
+    1.  Topics Concerning
+    2.  New Features
     2.  Resolved Issues
     3.  Known Issues
     4.  Firmware Requirements
@@ -15,309 +16,64 @@ This document describes the differences between v6.0.0-rc1 and v5.1.0.
 
 
 
+1. Topics Concerning
+====================
 
-1. New or Changed Features
+    - potentital memory leak in receiver
-==========================
+    - scanParameters in Python
+    - cmk.sh refactored
+    - m3 settings and threshold
 
-    Client 
+
+2. New Features
+===============
+
+    Client
     ------
 
-    1.  [Jungfrau] Chip version 
+    1. Aded settings and threshold features for Mythen3.
-        Features for chipv1.1 incorporated
+    2. Internal modification of acquire for Mythen3.
-        Command line: chipversion, API: getchipVersion 
+    3. Added getMaster functio for M3
-        gets chip version (1.0 or 1.1)
-        chipv1.1 requires config_jungfrau.txt on detector server.
-    
-    2.  [Jungfrau] Chip configuration (only chipv1.1)
-        powering on the chip and changing settings will configure the chip.
-        Hence, required before acquisition.
 
-    3.  [Jungfrau] Settings and Gain mode 
-        Settings can be gain0 and highgain0. Gain mode can be dynamicgain, 
-        forceswitchg1, forceswitchg2, fixg1, fixg2, fixg0. fixg0 must be 
-        used with EXTRA caution as you can damage the detector.
-        Changing settings also changes dac values of 3 dacs () and reconfigures
-        chip (only v1.1)
 
-    4.  [Jungfrau] Storage cells (only chipv1.1)
+    Mythen3 server
-        Additional number of storage cells not applicable for chipv1.1.
+    -----------------
-        Storage cell start is only allowed from 0 - 3 for chipv1.1 
-        (0 - 15 for chipv1.0).
-    
-    5.  [Gotthard2][Jungfrau] Filter Resistor 
-        Command line: filterresistor, API: getFilterResistor/ setFilterResistor
-        Previous Command: filter, setFilter/ getFilter
-        Set Filter resistor. Increasing values for increasing resistance.
-        [Jungfrau] only for chipv1.1. Options: [0|1]. Default is 1.
-        [Gotthard2] Options: [0|1|2|3]. Default is 0.
 
-    6.  [Jungfrau] Filter cell (only chipv1.1)
+    1. Setting timing to auto, sets timing to trigger for slaves
-        Command line: filtercell, API: getFilterCell/ setFilterCell
-        Set filter cell. Options: [0-12]. Advanced user command.
-
-    7.  [Jungfrau] Comparator disable time (only chipv1.1)
-        Command line: comp_disable_time, API: getComparatorDisableTime/ 
-        setComparatorDisableTime 
-        One can customize the period to disable comparator.
-
-    8.  [Eiger][Jungfrau] Flip rows
-        Command line: fliprows, API: getFlipRows/ setFlipRows
-        Previous command: flippeddatax, setBottom/ getBottom
-        [Jungfrau] Flips rows in detector only for HW v2.0.
-        slsReceiver and slsDetectorGui will not flip them again.
-        [Eiger] same as before.
-
-    9.  [Eiger][Jungfrau] Read n rows
-        Command line: readnrows, API: getReadNRows/ setReadNRows
-        Previous Command: readnlines, getPartialReadout/ setPartialReadout
-        [Eiger] same as before
-        [Jungfrau] Options: 8 - 512, multiples of 8. Default is 512.
-
-    10. [Gotthard2][Jungfrau] Current source 
-        Command line: currentsource, API: getCurrentSource, setCurrentSource
-        Enable or disable current source. Default is disabled.
-        [Gotthard2] Can only enable or disable.
-        [Jungfrau] Can choose to fix, select source and choose normal or low 
-        current. Normal/ low only for chipv1.1. 
-        Select source is 0-63 for chipv1.0 and a 64 bit mask for chipv1.1. 
-
-    11. Default dac 
-        Command line: defaultdac, API: getDefaultDac/ setDefaultDac
-        change default value of a dac
-        [Jungfrau][Mythen3] Also change default value of dac for particular 
-        setting.
-
-    12. Reset dacs
-        Command line: resetdacs, API: resetToDefaultDacs
-        Previous command: defaultdacs
-        Resets dacs to their default values or hard coded values.
-        
-    13. [Mythen3] Gain Capacitance
-        Command line: gaincaps, API: getGainCaps/ setGainCaps
-        Set various gain capacitances.
-
-    14. [Gotthard2] Veto Streaming from chip
-        Command line: veto, API: getVeto/ setVeto
-        This command used to mean veto streaming from detector. Now, it means
-        veto streaming from chip (New feature). Default is disabled.
-
-    15. [Gotthard2] Veto streaming from detector
-        Command line: vetostream, API: getVetoStream, setVetoStream
-        Options: None, local link interface, 10 10GbE, Both
-        Default: None
-        10GbE (as before) will enable 2 udp interfaces in receiver.
-
-    16. [Gotthard2] Veto algorithm
-        Command line: vetoalg, API: getVetoAlgorithm/ setVetoAlgorithm
-        Set veto algorithm for each interface.
-        Options: hits, raw
-        
-    17. [Eiger][Gotthard2][Mythen3] Module ID
-        Command line: moduleid, API: getModuleId
-        Previous command (Eiger only): serialnumber, getSerialNumber
-        Unique id read from txt file on detector and streamed out in udp header.
-    
-    18. [Gotthard2]
-        Command line: dbitpipeline, API: getDBITPipeline/ setDBITPipeline 
-        Set pipeline to latch digital bits. Options: 0-7
-
-    19. [Eiger][Jungfrau] Round Robin commands
-        Command line, udp_dstlist, API: getDestinationUDPList/ 
-        setDestinationUDPList
-        Round robin commands at the moment does not configure the receiver.
-        Set multiple udp destinations in the detector to stream udp data packets 
-        to. Upto 32 destinations. Refer documentation for details.
-
-        Command line, udp_numdst, API: getNumberofUDPDestinations
-
-        [Jungfrau] Command line, udp_firstdst, API: getFirstUDPDestination/ 
-        setFirstUDPDestination
-    
-    20. Command Line Parsing 
-        Parsing of detector index and module index has been modified to 
-        integrate round robin index.
-        [detector index]-[module index]:[round robin index] [command]
-
-        It is backwards compatible.
-        For ease, one can also execute
-        sls_detector_put [module index] [command]
-
-    21. Clear Udp Destination
-        Command line, udp_cleardst, API: clearUDPDestinations
-        This is useful when changing receivers for a detector or for round robin
-        system.
-
-    22. Shared Memory Naming
-        Shared memory name has been changed to reflect a more appropriate naming 
-        scheme.
-
-    23. [Eiger][Mythen3] Blocking trigger 
-        Command line: blockingtrigger, API: sendSoftwareTrigger
-        Sends software trigger signal to detector and blocks till frames are
-        sent out for that trigger.
-
-    24. [Eiger] Data stream enable for ports
-        Command line: datastream, API: getDataStream/ setDataStream
-        Enable or disable each port. Default: enabled
-
-    25. Changing TCP ports
-        This will only affect shared memory and will not try to change the
-        current tcp port of the control/stop server in detector.
-
-    26. [Eiger][Jungfrau][Gotthard2] Speed 
-        Command line: readoutspeed, readoutspeedlist API: getReadoutSpeed/ setReadoutSpeed /
-        getReadoutSpeedList
-        Previous command: speed, setSpeed/ getSpeed
-        [Eiger][Jungfrau] same as before.
-        [Gotthard2] New command to set readout speed. Options: 108, 144 (in MHz)
-        
-
-    Detector servers
-    ----------------
-
-    1.  [Gotthard2] Bad Channels moved to a new register, default settings 
-        including clock frequency changed
-
-    2.  [Gotthard2] Updated config file in detector server
     
 
-    Virtual servers
+3. Resolved Issues
-    ----------------
-
-    1.  Artifical pixel values increasing by every packet, instead of every pixel.
-
-    2.  All possible features updated.
-
-
-    Receiver
-    --------
-
-    1.  Frames caught in metadata
-        Frames caught by the master receiver is added to master file metadata.
-        Hdf5 and Binary version numbers changed to 6.3
-
-    2.  Removed Padding option for Deactivated half modules.
-
-    3.  Changing Receiver TCP ports
-        This will only affect shared memory and will not try to change the
-        current tcp port of the receiver.
-
-    Gui
-    ----
-
-    1. [Mythen3] counters added in settings tab
-
-
-2. Resolved Issues
 ==================
 
-    Detector Servers
-    ----------------
 
-    1.  [Gotthard2] Tolerance in time parameters. 
-        Eg. 220 ns was being set to 215 ns, instead of 222ns.
-
-    2.  [Jungfrau] Stopping in trigger mode and then switching to auto timing mode 
-        blocks data streaming from detector. Workaround fix made in 
-        detector server to reset core until next firmware release.
-
-    3.  [Jungfrau][CTB][Moench][Gotthard][Gotthard2][Mythen3] Firmware Programming
-        Firmware programming incorporates more validations such as checksum of 
-        program. Always ensure client and server are of same release before 
-        programming firmware.
-
-    4.  [Eiger] Stop sends last frame
-        Stop acquisition will now also send out all complete frames in fifo.
-
-    5.  [Eiger] Bottom not rotated in quad mode. Fixed.
-
-    6.  [Mythen3] counter mask effect on vthreshold
-        Setting counter mask changes vth daac values (ie. disabling sets to 2800),
-        vthreshold only changes for enabled counters, setting vth overwrites
-        dac even if counter disabled and when counters enabled, remembers set 
-        values.
-    
-    7.  [Eiger] fast quad fix for loading trimbits
-    
     Receiver
     --------
 
-    1.  Disabled port or deactivated (half) modules will not create files.
+    1.  Current code only calls Implementation::setDetectorType from constructor, 
+	    but potential memory leak if called out of constructor context. Fixed.
+
+    Client
+    ------
+
+    1.  Fixed missing scanParameters class in Python 
+
+    2.  cmk.sh refactored to have better option handling
 
 
-- better control of what is built (PR)?
-- cmake package has hardcoded path to zeromq library
 
 
-3. Firmware Requirements
+
+4. Firmware Requirements
 ========================
         
-    Eiger
+    No updates from 5.0.0
-    =====  
-    Compatible version : 08.10.2021 (v29)
-    
-    Jungfrau
-    ========       
-    Compatible version : 31.08.2021 (v1.2, PCB v1.0) 
-                       : 08.10.2021 (v2.2, PCB v2.0)
-
-    Gotthard
-    ========   
-    Compatible version : 08.02.2018 (50um and 25um Master)
-                       : 09.02.2018 (25 um Slave) 
-
-    Mythen3
-    =======
-    Compatible version : 10.09.2021 (development)
-
-    Gotthard2
-    =========
-    Compatible version : 27.05.2021 (v1.0)
-
-    Moench
-    ======
-    Compatible version : 05.10.2020 (v1.0)
-
-    Ctb
-    ===
-    Compatible version : 05.10.2020 (v1.0)
-
-    Detector Upgrade
-    ================
-
-    The following can be upgraded remotely:
-    Eiger      via bit files
-    Jungfrau   via command <.pof>
-    Mythen3    via command <.rbf>
-    Gotthard2  via command <.rbf> 
-    Moench     via command <.pof>
-    Ctb        via command <.pof>
-
-    The following cannot be upgraded remotely:
-    Gotthard   
-
-    Instructions available at
-        https://slsdetectorgroup.github.io/devdoc/firmware.html
-    and
-        https://slsdetectorgroup.github.io/devdoc/serverupgrade.html
-
-
 
 
 
 5. Known Issues
 ===============
 
-    Receiver
+    No updates from 5.0.0
-    --------
-    1.  It does not handle readnrows or partial readout. Only the summary
-        is adjusted to print in red. However, it will still write complete
-        images with missing data padded. Roi will be implemented in future
-        that can be complimented with this feature to remove the additional
-        data in files.
-
-    2.  Round robin is not implemented in receiver side, ie. one cannot configure
-        more than 1 receiver at a time. This will/might be done in the future.
 
 
 

cmake/FindZeroMQ.cmake

@@ -0,0 +1,112 @@
+
+# This file is originally from https://github.com/zeromq/azmq and distributed 
+# under Boost Software Lincese 1.0
+# Boost Software License - Version 1.0 - August 17th, 2003
+
+# Permission is hereby granted, free of charge, to any person or organization
+# obtaining a copy of the software and accompanying documentation covered by
+# this license (the "Software") to use, reproduce, display, distribute,
+# execute, and transmit the Software, and to prepare derivative works of the
+# Software, and to permit third-parties to whom the Software is furnished to
+# do so, all subject to the following:
+
+# The copyright notices in the Software and this entire statement, including
+# the above license grant, this restriction and the following disclaimer,
+# must be included in all copies of the Software, in whole or in part, and
+# all derivative works of the Software, unless such copies or derivative
+# works are solely in the form of machine-executable object code generated by
+# a source language processor.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+# SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+# FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+# --------------------------------------------------------------------------------
+
+# Find ZeroMQ Headers/Libs
+
+# Variables
+# ZMQ_ROOT - set this to a location where ZeroMQ may be found
+#
+# ZeroMQ_FOUND - True of ZeroMQ found
+# ZeroMQ_INCLUDE_DIRS - Location of ZeroMQ includes
+# ZeroMQ_LIBRARIES - ZeroMQ libraries
+
+include(FindPackageHandleStandardArgs)
+
+if (NOT ZMQ_ROOT)
+    set(ZMQ_ROOT "$ENV{ZMQ_ROOT}")
+endif()
+
+if (NOT ZMQ_ROOT)
+    find_path(_ZeroMQ_ROOT NAMES include/zmq.h)
+else()
+    set(_ZeroMQ_ROOT "${ZMQ_ROOT}")
+endif()
+
+find_path(ZeroMQ_INCLUDE_DIRS NAMES zmq.h HINTS ${_ZeroMQ_ROOT}/include)
+
+if (ZeroMQ_INCLUDE_DIRS)
+    set(_ZeroMQ_H ${ZeroMQ_INCLUDE_DIRS}/zmq.h)
+
+    function(_zmqver_EXTRACT _ZeroMQ_VER_COMPONENT _ZeroMQ_VER_OUTPUT)
+        set(CMAKE_MATCH_1 "0")
+        set(_ZeroMQ_expr "^[ \\t]*#define[ \\t]+${_ZeroMQ_VER_COMPONENT}[ \\t]+([0-9]+)$")
+        file(STRINGS "${_ZeroMQ_H}" _ZeroMQ_ver REGEX "${_ZeroMQ_expr}")
+        string(REGEX MATCH "${_ZeroMQ_expr}" ZeroMQ_ver "${_ZeroMQ_ver}")
+        set(${_ZeroMQ_VER_OUTPUT} "${CMAKE_MATCH_1}" PARENT_SCOPE)
+    endfunction()
+
+    _zmqver_EXTRACT("ZMQ_VERSION_MAJOR" ZeroMQ_VERSION_MAJOR)
+    _zmqver_EXTRACT("ZMQ_VERSION_MINOR" ZeroMQ_VERSION_MINOR)
+    _zmqver_EXTRACT("ZMQ_VERSION_PATCH" ZeroMQ_VERSION_PATCH)
+
+    message(STATUS "ZeroMQ version: ${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
+
+    # We should provide version to find_package_handle_standard_args in the same format as it was requested,
+    # otherwise it can't check whether version matches exactly.
+    if (ZeroMQ_FIND_VERSION_COUNT GREATER 2)
+        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}.${ZeroMQ_VERSION_PATCH}")
+    else()
+        # User has requested ZeroMQ version without patch part => user is not interested in specific patch =>
+        # any patch should be an exact match.
+        set(ZeroMQ_VERSION "${ZeroMQ_VERSION_MAJOR}.${ZeroMQ_VERSION_MINOR}")
+    endif()
+
+    if (NOT ${CMAKE_CXX_PLATFORM_ID} STREQUAL "Windows")
+        find_library(ZeroMQ_LIBRARIES NAMES zmq HINTS ${_ZeroMQ_ROOT}/lib)
+    else()
+        find_library(
+            ZeroMQ_LIBRARY_RELEASE
+            NAMES
+                libzmq
+                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
+            HINTS
+                ${_ZeroMQ_ROOT}/lib
+            )
+
+        find_library(
+            ZeroMQ_LIBRARY_DEBUG
+            NAMES
+                libzmq_d
+                "libzmq-${CMAKE_VS_PLATFORM_TOOLSET}-mt-gd-${ZeroMQ_VERSION_MAJOR}_${ZeroMQ_VERSION_MINOR}_${ZeroMQ_VERSION_PATCH}"
+            HINTS
+                ${_ZeroMQ_ROOT}/lib)
+
+        # On Windows we have to use corresponding version (i.e. Release or Debug) of ZeroMQ because of `errno` CRT global variable
+        # See more at http://www.drdobbs.com/avoiding-the-visual-c-runtime-library/184416623
+        set(ZeroMQ_LIBRARIES optimized "${ZeroMQ_LIBRARY_RELEASE}" debug "${ZeroMQ_LIBRARY_DEBUG}")
+    endif()
+endif()
+
+find_package_handle_standard_args(ZeroMQ FOUND_VAR ZeroMQ_FOUND
+    REQUIRED_VARS ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES
+    VERSION_VAR ZeroMQ_VERSION)
+
+if (ZeroMQ_FOUND)
+    mark_as_advanced(ZeroMQ_INCLUDE_DIRS ZeroMQ_LIBRARIES ZeroMQ_VERSION
+        ZeroMQ_VERSION_MAJOR ZeroMQ_VERSION_MINOR ZeroMQ_VERSION_PATCH)
+endif()

cmake/package_config.cmake

@@ -25,12 +25,6 @@ install(FILES
   DESTINATION ${CMAKE_INSTALL_DIR}
 )
 
-install(FILES
-  "${CMAKE_SOURCE_DIR}/libzmq-pkg-config/FindZeroMQ.cmake"
-  COMPONENT devel
-  DESTINATION ${CMAKE_INSTALL_DIR}/libzmq-pkg-config
-)
-
 if (PROJECT_LIBRARIES OR PROJECT_STATIC_LIBRARIES)
   install(
     EXPORT "${TARGETS_EXPORT_NAME}"

cmake/project-config.cmake.in

@@ -12,21 +12,8 @@ include(CMakeFindDependencyMacro)
 
 set(SLS_USE_HDF5 "@SLS_USE_HDF5@")
 
-
-find_package(ZeroMQ 4 QUIET)
-# libzmq autotools install: fallback to pkg-config
-if(NOT ZeroMQ_FOUND)
-    list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/libzmq-pkg-config)
-    find_package(ZeroMQ 4 REQUIRED)
-endif()
-
-if(NOT ZeroMQ_FOUND)
-    message(FATAL_ERROR "ZeroMQ was NOT found!")
-endif()
-
-find_dependency(Threads)
-
 # Add optional dependencies here
+find_dependency(Threads)
 if (SLS_USE_HDF5)
     find_dependency(HDF5)
 endif ()

conda-recepie/build.sh

@@ -8,15 +8,13 @@ cmake .. \
       -DSLS_USE_TEXTCLIENT=ON \
       -DSLS_USE_RECEIVER=ON \
       -DSLS_USE_GUI=ON \
-      -DSLS_USE_MOENCH=ON\
       -DSLS_USE_TESTS=ON \
       -DSLS_USE_PYTHON=OFF \
       -DCMAKE_BUILD_TYPE=Release \
       -DSLS_USE_HDF5=OFF\
      
-NCORES=$(getconf _NPROCESSORS_ONLN)
+
-echo "Building using: ${NCORES} cores"
+cmake --build . -- -j10
-cmake --build . -- -j${NCORES}
 cmake --build . --target install
 
-CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2
+CTEST_OUTPUT_ON_FAILURE=1 ctest -j 2

conda-recepie/copy_gui.sh

@@ -1,3 +1,3 @@
 #Copy the GUI 
-mkdir -p $PREFIX/bin
+mkdir $PREFIX/bin
-cp build/install/bin/slsDetectorGui $PREFIX/bin/.
+cp build/bin/slsDetectorGui $PREFIX/bin/.

conda-recepie/copy_lib.sh

@@ -1,6 +1,6 @@
 
-mkdir -p $PREFIX/lib
+mkdir $PREFIX/lib
-mkdir -p $PREFIX/bin
+mkdir $PREFIX/bin
 mkdir -p $PREFIX/include/sls
 # mkdir $PREFIX/include/slsDetectorPackage
 

conda-recepie/copy_moench.sh

@@ -1,4 +0,0 @@
-#Copy the Moench executables 
-mkdir -p $PREFIX/bin
-cp build/install/bin/moench04ZmqProcess $PREFIX/bin/.
-cp build/install/bin/moenchZmqProcess $PREFIX/bin/.

conda-recepie/meta.yaml

@@ -59,16 +59,6 @@ outputs:
     script: copy_lib.sh
 
     requirements:
-      build:
-        - {{ compiler('c') }}
-        - {{compiler('cxx')}}
-        - libstdcxx-ng
-        - libgcc-ng
-        - zeromq
-
-      host:
-        - zeromq
-
       run: 
         - libstdcxx-ng
         - libgcc-ng
@@ -88,8 +78,6 @@ outputs:
 
       host:
         - python
-        - {{ pin_subpackage('slsdetlib', exact=True) }}
-
 
       run:
         - libstdcxx-ng
@@ -106,29 +94,8 @@ outputs:
   - name: slsdetgui
     script: copy_gui.sh
     requirements:
-
-      build:
-        - {{ compiler('c') }}
-        - {{compiler('cxx')}}
-        - {{ pin_subpackage('slsdetlib', exact=True) }}
-        - qwt 6.*
-
       run:
         - {{ pin_subpackage('slsdetlib', exact=True) }}
         - qwt 6.*
         - qt 4.8.*
         - expat
-
-  - name: moenchzmq
-    script: copy_moench.sh
-    requirements:
-
-      build:
-        - {{ compiler('c') }}
-        - {{compiler('cxx')}}
-        - {{ pin_subpackage('slsdetlib', exact=True) }}
-
-
-      run:
-        - {{ pin_subpackage('slsdetlib', exact=True) }}
-        - expat

docs/src/firmware.rst

@@ -154,8 +154,6 @@ Upgrade (from v5.0.0)
 
 Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you run into issues while programming firmware.
 
-Always ensure that the client and server software are of the same release.
-
 
 #. Program from console
     .. code-block:: bash
@@ -224,8 +222,6 @@ Download
 Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Always ensure that the client and server software are of the same release.
-
 #. Program from console
     .. code-block:: bash
 
@@ -255,8 +251,6 @@ Download
 Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Always ensure that the client and server software are of the same release.
-
 #. Program from console
     .. code-block:: bash
 
@@ -284,8 +278,6 @@ Upgrade (from v5.0.0)
 
 Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you run into issues while programming firmware.
 
-Always ensure that the client and server software are of the same release.
-
 #. Program from console
     .. code-block:: bash
 
@@ -312,8 +304,6 @@ Upgrade (from v5.0.0)
 
 Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you run into issues while programming firmware.
 
-Always ensure that the client and server software are of the same release.
-
 #. Program from console
     .. code-block:: bash
 
@@ -354,43 +344,26 @@ Firmware Troubleshooting with blackfin
 
 5. If one can't list it, read the next section to try to get the blackfin to list it.
 
-How to get back mtd3 drive remotely (copying new kernel)
+How to get back mtd3 drive remotely
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+This might take a few reruns (maybe even 10) until the mtd drive is accessed by the blackfin upon linux startup.
 
   .. code-block:: bash
     
-    # step 1: get the kernel image (uImage.lzma) from slsdetectorgroup
+    # step 1: connect to the board
-    # and copy it to pc's tftp folder
-
-    # step 2: connect to the board
     telnet bchipxxx
 
-    #step 3: go to directory for space
+    # step 2: check if mtd3 drive listed
-    cd /var/tmp/
+    more /proc/mtd
 
-    # step 3: copy kernel to board
+    # step 3: tell fpga not to touch flash and reboot
-    tftp pcxxx -r uImage.lzma -g
+    echo 9 > /sys/class/gpio/export; 
-
+    echo out > /sys/class/gpio/gpio9/direction; 
-    # step 4: verify kernel copied properly
+    echo 0 > /sys/class/gpio/gpio9/value;
-    ls -lrt
-    
-    # step 5: erase flash
-    flash_eraseall /dev/mtd1
-    
-    # step 6: copy new image to kernel drive
-    cat uImage.lzma > /dev/mtd1
-    
-    # step 7:
-    sync
-    
-    # step 8:
     reboot
-    
+
-    # step 9: verification
+    # step 4: repeat steps 1 - 3 until you see the mtd3 drive
-    telnet bchipxxx
+
-    uname -a # verify kernel date
-    more /proc/mtd # verify mtd3 is listed
-    
 
 Last Resort using USB Blaster
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

docs/src/pyenums.rst

@@ -67,6 +67,9 @@ exposed to Python through pybind11.
 .. autoclass:: readoutMode
     :undoc-members:
 
+.. autoclass:: masterFlags
+    :undoc-members:
+
 .. autoclass:: burstMode
     :undoc-members:
 

docs/src/pygettingstarted.rst

@@ -219,7 +219,7 @@ The enums can be found in slsdet.enums
     >>> [e for e in dir(slsdet.enums) if not e.startswith('_')]
     ['burstMode', 'clockIndex', 'dacIndex', 
     'detectorSettings', 'detectorType', 'dimension', 'externalSignalFlag', 
-    'fileFormat', 'frameDiscardPolicy', 
+    'fileFormat', 'frameDiscardPolicy', 'masterFlags', 
     'readoutMode', 'runStatus', 'speedLevel', 'timingMode', 
     'timingSourceType']
 

docs/src/servers.rst

@@ -34,62 +34,3 @@ Detector Servers include:
       *  Client requests for detector status, stop acquisition, temperature, advanced read/write registers.
 
 When using a blocking acquire command (sls_detector_acquire or Detector::acquire), the control server is blocked until end of acquisition. However, stop server commands could be used in parallel.
-
-
-Automatic start 
-------------------
-
-One can start the on-board detector server automatically upon powering on the board.
-
-#. Create a soft link to the binary on board 
-   :
-      .. code-block:: bash
-      
-         ln -sf someDetectorServervx.x.x someDetectorServer
-
-
-
-#. Do the following depending on the detector type :
-
-   Eiger
-      .. code-block:: bash
-         
-         # create script in rc5.d on the board
-         vi /etc/rc5.d/S50board_com.sh
-
-         # enter the following (edit server name)
-         #! /bin/sh
-         /home/root/executables/eigerDetectorServer &> /dev/null &
-         exit 0
-
-   Jungfrau | Moench | CTB | Gotthard I
-      .. code-block:: bash
-
-         # Edit inittab on board
-         vi /etc/inittab
-
-         # enter the following line
-         ttyS0::respawn:/./xxxDetectorServer
-
-
-   Gotthard II | Mythen III
-      .. code-block:: bash
-         
-         # create script in init.d on board
-         vi /etc/init.d/S99detServer.sh
-
-         # enter the following (edit server name)
-         #! /bin/sh
-         cd /root >> /dev/null
-         /root/xxxDetectorServer >> /dev/null &
-
-
-#. Sync, reboot and verify
-   :
-      .. code-block:: bash
-      
-         sync
-         reboot
-
-         # verify
-         ps -ef | grep xxxDetectorServer

examples/moench03_T1.config

@@ -1,8 +1,7 @@
-#initialchecks 0
+initialchecks 0
 #############################################
 ### edit with hostname or IP address of your detector 
 ############################################
-#hostname bchip181+
 hostname bchip181+
 
 #############################################
@@ -28,7 +27,7 @@ rx_zmqport 50003
 #############################################
 ### edit with 1 Gbs IP of PC where you will run the GUI
 ############################################
-zmqip 129.129.202.98
+zmqip 129.129.202.136
 zmqport 50001
 
 
@@ -40,12 +39,11 @@ rx_zmqstream 1
 
 frames 100000
 period 0.0006
-exptime 0.00035
 
 #############################################
 ### edit with directory you want to write to
 ############################################
-fpath /mnt/moench_data/scratch1/
+fpath /mnt/moench_data/scratch/
 
 fwrite 0
 

integrationTests/test-integrationDectector.cpp

@@ -488,7 +488,7 @@ TEST_CASE("Eiger or Jungfrau nextframenumber",
     CHECK(m.getNextFrameNumber() == (val + 1));
 }
 
-TEST_CASE("Eiger partialread", "[.eigerintegration][partialread]") {
+TEST_CASE("Eiger readnlines", "[.eigerintegration][readnlines]") {
     SingleDetectorConfig c;
 
     // pick up multi detector from shm id 0
@@ -501,16 +501,16 @@ TEST_CASE("Eiger partialread", "[.eigerintegration][partialread]") {
 
     m.setDynamicRange(16);
     m.enableTenGigabitEthernet(0);
-    m.setPartialReadout(256);
+    m.setReadNLines(256);
-    CHECK(m.getPartialReadout() == 256);
+    CHECK(m.getReadNLines() == 256);
-    m.setPartialReadout(1);
+    m.setReadNLines(1);
-    CHECK(m.getPartialReadout() == 1);
+    CHECK(m.getReadNLines() == 1);
 
     m.setDynamicRange(8);
-    m.setPartialReadout(256);
+    m.setReadNLines(256);
-    CHECK(m.getPartialReadout() == 256);
+    CHECK(m.getReadNLines() == 256);
-    CHECK_THROWS_AS(m.setPartialReadout(1), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setReadNLines(1), sls::RuntimeError);
-    CHECK(m.getPartialReadout() == 256);
+    CHECK(m.getReadNLines() == 256);
-    CHECK_THROWS_AS(m.setPartialReadout(0), sls::RuntimeError);
+    CHECK_THROWS_AS(m.setReadNLines(0), sls::RuntimeError);
-    m.setPartialReadout(256);
+    m.setReadNLines(256);
 }

libzmq-pkg-config/FindZeroMQ.cmake

@@ -1,27 +0,0 @@
-#From: https://github.com/zeromq/cppzmq/
-set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON)
-find_package(PkgConfig)
-pkg_check_modules(PC_LIBZMQ QUIET libzmq)
-
-set(ZeroMQ_VERSION ${PC_LIBZMQ_VERSION})
-find_library(ZeroMQ_LIBRARY NAMES libzmq.so libzmq.dylib libzmq.dll
-             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-find_library(ZeroMQ_STATIC_LIBRARY NAMES libzmq-static.a libzmq.a libzmq.dll.a
-             PATHS ${PC_LIBZMQ_LIBDIR} ${PC_LIBZMQ_LIBRARY_DIRS})
-
-if(ZeroMQ_LIBRARY OR ZeroMQ_STATIC_LIBRARY)
-    set(ZeroMQ_FOUND ON)
-endif()
-
-if (TARGET libzmq)
-    # avoid errors defining targets twice
-    return()
-endif()
-
-add_library(libzmq SHARED IMPORTED)
-set_property(TARGET libzmq PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq PROPERTY IMPORTED_LOCATION ${ZeroMQ_LIBRARY})
-
-add_library(libzmq-static STATIC IMPORTED ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PC_LIBZMQ_INCLUDE_DIRS})
-set_property(TARGET libzmq-static PROPERTY IMPORTED_LOCATION ${ZeroMQ_STATIC_LIBRARY})

notice_to_add_for_every_file

@@ -1,16 +0,0 @@
-    Copyright (C) 2021 Contributors to the SLS Detector Package
-    
-    This file is part of the SLS Detecotor Package.
-
-    SLS Detecotor Package is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    SLS Detecotor Package is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with SLS Detecotor Package.  If not, see <https://www.gnu.org/licenses/>.

python/CMakeLists.txt

@@ -6,7 +6,6 @@ pybind11_add_module(_slsdet
     src/network.cpp
     src/pattern.cpp
     src/scan.cpp
-    src/current.cpp
 )
 
 target_link_libraries(_slsdet PUBLIC 

python/examples/use_currentsource.py

@@ -1,11 +0,0 @@
-from slsdet import Detector, currentSrcParameters
-
-s = currentSrcParameters()
-s.enable = 1
-s.fix= 1
-s.normal = 1
-s.select = 10
-
-
-d = Detector()
-d.currentsource = s

python/examples/using_scan.py

@@ -15,7 +15,5 @@ sp.dacSettleTime_ns = int(1e9)
 d = Mythen3()
 d.setScan(sp)
 
-#or d.scan = sp
-
 
 

python/scripts/compile_servers.py

@@ -1,80 +0,0 @@
-import subprocess
-import os
-import sys
-from pathlib import Path
-import shutil as sh
-from argparse import ArgumentParser
-
-class color:
-    HEADER = "\033[95m"
-    BLUE = "\033[94m"
-    CYAN = "\033[96m"
-    GREEN = "\033[92m"
-    YELLOW = "\033[93m"
-    RED = "\033[91m"
-    ENDC = "\033[0m"
-    BOLD = "\033[1m"
-    UNDERLINE = "\033[4m"
-    MAGENTA = "\033[35m"
-
-    @staticmethod
-    def red(s):
-        return f"{color.RED}{s}{color.ENDC}"
-
-    @staticmethod
-    def green(s):
-        return f"{color.GREEN}{s}{color.ENDC}"
-
-def add_to_path():
-    paths = [
-        "/opt/uClinux/bfin-uclinux/bin",
-        "/opt/nios2-gcc/bin",
-        "/opt/eldk-5.1/powerpc-4xx-softfloat/sysroots/i686-eldk-linux/usr/bin/ppc405-linux",
-    ]
-    os.environ["PATH"] += os.pathsep + os.pathsep.join(paths)
-
-
-def rc_to_string(rc):
-    if rc == 0:
-        return color.green("OK")
-    else:
-        return color.red("FAIL")
-
-
-
-parser = ArgumentParser()
-parser.add_argument('-t', '--tag', help = 'Tag added to server file name', default='developer')
-parser.add_argument('-g', '--git', help='Add new servers to the git repo', action="store_true")
-args = parser.parse_args()
-
-
-servers = [
-#     "eigerDetectorServer",
-#     "jungfrauDetectorServer",
-      "mythen3DetectorServer",
-#     "gotthard2DetectorServer",
-#     "gotthardDetectorServer",
-#     "ctbDetectorServer",
-#     "moenchDetectorServer",
-]
-
-
-server_root = Path("../../slsDetectorServers/").resolve()
-
-add_to_path()
-for server in servers:
-    bin_name = f"{server}_{args.tag}"
-    path = server_root / server
-    print(f"{bin_name} - ", end="")
-    os.chdir(path)
-    try: 
-        sh.rmtree(path/'bin')
-    except FileNotFoundError:
-        pass
-    p = subprocess.run(["make"], stdout=subprocess.DEVNULL)
-    print(rc_to_string(p.returncode))
-    if p.returncode == 0:
-        sh.move(f"bin/{server}", f"bin/{bin_name}")
-        if args.git:
-            print("Adding to git")
-            subprocess.run(['git', 'add', 'bin', '-f'])

python/scripts/generate_enums.py

@@ -11,30 +11,14 @@ import subprocess
 
 from parse import remove_comments
 
-allow_bitwise_op = ["M3_GainCaps"]
-allow_bitwise_op = ["streamingInterface"]
-
-op_key = {"operator|": "__or__", 
-          "operator&" : "__and__"}
-
 def single_line_enum(line):
     sub = line[line.find('{')+1:line.find('}')]
     return sub.strip().split(',')
 
 def extract_enums(lines):
-
-    # deal with enum class streamingInterface : int32_t
-    # and normal enum burstMode {
-
     line_iter = iter(lines)
     enums = {}
     for line in line_iter:
-        #Hack away class enum defs
-        if "class" in line:
-            line = line.replace("class", "")
-            line = line.replace(line[line.find(':'):line.find('{')], "")
-            line = line.replace("  ", " ")
-
         m = re.search("(?<=enum )\w+(?= {)", line)
         if m:
             enum_name = m.group()
@@ -60,80 +44,25 @@ def extract_enums(lines):
                         pass
             fields = [f.strip() for f in fields]
             enums[enum_name] = fields
-
-
-    #Loop again to find operators
-    for key in enums:
-        for line in lines:
-            if key in line and "operator" in line:
-                pos = line.find("operator")
-                op_type = line[pos:pos+9]
-                enums[key].append(op_type)
     return enums
 
-
 def generate_enum_string(enums):
     data = []
     for key, value in enums.items():
-        if key in allow_bitwise_op:
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
-            tag=", py::arithmetic()"
-        else:
-            tag=""
-        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}"{tag})\n')
-        operators = []
         for v in value:
-            if "operator" not in v:
+            data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
-                data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
+        data.append('.export_values();\n\n')
-            else:
-                operators.append(v)
-        data.append('\t.export_values()')
-
-        #Here add the operators 
-        for op in operators:
-            data.append(f"\n\t.def(\"{op_key[op]}\", py::overload_cast< const slsDetectorDefs::streamingInterface&,  const slsDetectorDefs::streamingInterface&>(&{op}))")
-
-
-        data.append(';\n\n')
     return ''.join(data)
 
-
-def remove_ifdefs(lines):
-    """Keeps C++ version of the code"""
-    out = []
-    it = iter(lines)
-    skip = False
-    for line in it:
-        
-        if "#ifdef __cplusplus" in line:
-            line = next(it)
-
-        if "#else" in line:
-            skip = True
-
-        if "#endif" in line:
-            skip = False
-
-        if not skip and "#endif" not in line:    
-            out.append(line)
-    return out
-    
-
 with open('../../slsSupportLib/include/sls/sls_detector_defs.h') as f:
     data = f.read()
 
 data = remove_comments(data)
 data = data.splitlines()
-data = remove_ifdefs(data)
 enums = extract_enums(data)
-
-
 s = generate_enum_string(enums)
 
-# print(s)
-# for i, line in enumerate(data):
-#     print(i, line)
-
-
 with open('../src/enums_in.cpp') as f:
     data = f.read()
 

python/scripts/test_virtual.py

@@ -101,11 +101,15 @@ def test_module_size(virtual_jf_detectors):
 
 def test_settings(virtual_jf_detectors):
     d = ExperimentalDetector()
-    assert d.settings == detectorSettings.GAIN0
+    assert d.settings == detectorSettings.DYNAMICGAIN
 
     gain_list = [
-        detectorSettings.GAIN0,
+        detectorSettings.FIXGAIN1,
-        detectorSettings.HIGHGAIN0,
+        detectorSettings.FIXGAIN2,
+        detectorSettings.FORCESWITCHG1,
+        detectorSettings.FORCESWITCHG2,
+        detectorSettings.DYNAMICHG0,
+        detectorSettings.DYNAMICGAIN,
     ]
 
     # Set all viable gain for Jungfrau to make sure nothing is crashing
@@ -113,14 +117,15 @@ def test_settings(virtual_jf_detectors):
         d.settings = gain
         assert d.settings == gain
 
-    d.setSettings(detectorSettings.GAIN0, [1])
+    d.setSettings(detectorSettings.FORCESWITCHG1, [1])
     assert d.settings == [
-        detectorSettings.GAIN0,
+        detectorSettings.DYNAMICGAIN,
-        detectorSettings.HIGHGAIN0,
+        detectorSettings.FORCESWITCHG1,
+        detectorSettings.DYNAMICGAIN,
     ]
 
-    d.settings = detectorSettings.GAIN0
+    d.settings = detectorSettings.DYNAMICGAIN
-    assert d.settings == detectorSettings.GAIN0
+    assert d.settings == detectorSettings.DYNAMICGAIN
 
 def test_frames(virtual_jf_detectors):
     d = ExperimentalDetector()
@@ -156,34 +161,4 @@ def test_period(virtual_jf_detectors):
     d.period  = t
     assert d.period == 10e-6
 
-def test_gainmode(virtual_jf_detectors):
+    
-    d = ExperimentalDetector()
-    assert d.gainMode == gainMode.NORMAL_GAIN_MODE
-
-    gain_list = [
-        gainMode.DYNAMIC,
-        gainMode.FORCE_SWITCH_G1,
-        gainMode.FORCE_SWITCH_G2,
-        gainMode.FIX_G1,
-        gainMode.FIX_G2,
-        gainMode.FIX_G0
-    ]
-
-    # Set all viable gain for Jungfrau to make sure nothing is crashing
-    for gain in gain_list:
-        d.gainMode = gain
-        assert d.gainMode == gain
-
-    d.setGainMode(gainMode.FORCE_SWITCH_G1, [1])
-    assert d.gainMode == [
-        gainMode.DYNAMIC,
-        gainMode.FORCE_SWITCH_G1,
-        gainMode.FORCE_SWITCH_G2,
-        gainMode.FIX_G1,
-        gainMode.FIX_G2,
-        gainMode.FIX_G0
-    ]
-
-    d.gainMode = gainMode.FORCE_SWITCH_G1
-    assert d.gainMode == gainMode.FORCE_SWITCH_G1
-    

python/slsdet/__init__.py

@@ -20,5 +20,4 @@ from .enums import *
 
 IpAddr = _slsdet.IpAddr
 MacAddr = _slsdet.MacAddr
-scanParameters = _slsdet.scanParameters
+scanParameters = _slsdet.scanParameters
-currentSrcParameters = _slsdet.currentSrcParameters

python/slsdet/detector.py

@@ -7,9 +7,6 @@ timingMode = slsDetectorDefs.timingMode
 speedLevel = slsDetectorDefs.speedLevel
 dacIndex = slsDetectorDefs.dacIndex
 detectorType = slsDetectorDefs.detectorType
-streamingInterface = slsDetectorDefs.streamingInterface
-
-defs = slsDetectorDefs
 
 from .utils import element_if_equal, all_equal, get_set_bits, list_to_bitmask
 from .utils import Geometry, to_geo, element, reduce_time, is_iterable
@@ -311,7 +308,7 @@ class Detector(CppDetectorApi):
         -----
         
         [Eiger] Use threshold command to load settings
-        [Jungfrau] GAIN0, HIGHGAIN0 \n
+        [Jungfrau] DYNAMICGAIN, DYNAMICHG0, FIXGAIN1, FIXGAIN2, FORCESWITCHG1, FORCESWITCHG2 \n
         [Gotthard] DYNAMICGAIN, HIGHGAIN, LOWGAIN, MEDIUMGAIN, VERYHIGHGAIN \n
         [Gotthard2] DYNAMICGAIN, FIXGAIN1, FIXGAIN2 \n
         [Moench] G1_HIGHGAIN, G1_LOWGAIN, G2_HIGHCAP_HIGHGAIN, G2_HIGHCAP_LOWGAIN, G2_LOWCAP_HIGHGAIN, G2_LOWCAP_LOWGAIN, G4_HIGHGAIN, G4_LOWGAIN \n
@@ -362,21 +359,6 @@ class Detector(CppDetectorApi):
         """
         return self.getNumberOfFramesFromStart()
 
-
-    @property
-    @element
-    def scan(self):
-        """
-        Pass in a scanParameters object 
-        see python/examples/use_scan.py
-
-        """
-        return self.getScan()
-
-    @scan.setter
-    def scan(self, s):
-        ut.set_using_dict(self.setScan, s)
-
     @property
     @element
     def powerchip(self):
@@ -385,7 +367,7 @@ class Detector(CppDetectorApi):
         Note
         ----
         [Moench] Default is disabled. \n
-        [Jungfrau] Default is disabled. Get will return power status. Can be off if temperature event occured (temperature over temp_threshold with temp_control enabled. Will configure chip (only chip v1.1).\n
+        [Jungfrau] Default is disabled. Get will return power status. Can be off if temperature event occured (temperature over temp_threshold with temp_control enabled. \n
         [Mythen3][Gotthard2] Default is 1. If module not connected or wrong module, powerchip will fail.
         """
         return self.getPowerChip()
@@ -1645,22 +1627,20 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def readoutspeed(self):
+    def speed(self):
         """
-        [Eiger][Jungfrau|Gotthard2] Readout speed of chip. Enum: speedLevel
+        [Eiger][Jungfrau] Readout speed of chip. Enum: speedLevel
         Note
         -----
-        [Jungfrau] FULL_SPEED, HALF_SPEED (Default), QUARTER_SPEED
+        Options: FULL_SPEED, HALF_SPEED, QUARTER_SPEED \n
-        [Eiger] FULL_SPEED (Default), HALF_SPEED, QUARTER_SPEED
+        [Jungfrau] FULL_SPEED option only available from v2.0 boards and with setting number of interfaces to 2.  \n
-        [Gottthard2] G2_108MHZ (Default), G2_144MHZ
-        [Jungfrau] FULL_SPEED option only available from v2.0 boards and is recommended to set number of interfaces to 2.  \n
         Also overwrites adcphase to recommended default.
         """
-        return element_if_equal(self.getReadoutSpeed())
+        return element_if_equal(self.getSpeed())
 
-    @readoutspeed.setter
+    @speed.setter
-    def readoutspeed(self, value):
+    def speed(self, value):
-        ut.set_using_dict(self.setReadoutSpeed, value)
+        ut.set_using_dict(self.setSpeed, value)
 
     @property
     def rx_jsonpara(self):
@@ -1769,7 +1749,7 @@ class Detector(CppDetectorApi):
         Note
         ----
         [Eiger] Sets vcmp_ll, vcmp_lr, vcmp_rl, vcmp_rr and vcp to the same value. \n
-        [Mythen3] Sets vth1, vth2 and vth3 to the same value for enabled counters.
+        [Mythen3] Sets vth1, vth2 and vth3 to the same value.
         """
         return self.getDAC(dacIndex.VTHRESHOLD)
 
@@ -1807,25 +1787,10 @@ class Detector(CppDetectorApi):
 
     """
 
-    <<<Eiger>>>
+    <<<-----------------------Eiger specific----------------------->>>
 
     """
 
-    @property
-    def datastream(self):
-        """
-        datastream [left|right] [0, 1]
-	    [Eiger] Enables or disables data streaming from left or/and right side of detector. 1 (enabled) by default.
-        """
-        result = {}
-        for port in [defs.LEFT, defs.RIGHT]:
-            result[port] = element_if_equal(self.getDataStream(port))
-        return result
-
-    @datastream.setter
-    def datastream(self, value):
-        ut.set_using_dict(self.setDataStream, *value)
-
     @property
     @element
     def quad(self):
@@ -1863,21 +1828,19 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def readnrows(self):
+    def readnlines(self):
         """
-        [Eiger] Number of rows to read out per half module starting from the centre.
+        [Eiger] Number of lines to read out per half module 
-        [Jungfrau] Number of rows to read per module starting from the centre.
         Note
         ----
-        [Eiger] Options: 1 - 256. 256 is default. \n
+        Options: 0 - 256. 256 is default. \n
-        [Eiger]The permissible values depend on dynamic range and 10Gbe enabled.\n\n
+        The permissible values depend on dynamic range and 10Gbe enabled.
-        [Jungfrau] Options: 8 - 512 (multiples of 8)
         """
-        return self.getReadNRows()
+        return self.getPartialReadout()
 
-    @readnrows.setter
+    @readnlines.setter
-    def readnrows(self, value):
+    def readnlines(self, value):
-        ut.set_using_dict(self.setReadNRows, value)
+        ut.set_using_dict(self.setPartialReadout, value)
 
 
     @property
@@ -2008,23 +1971,9 @@ class Detector(CppDetectorApi):
         return ut.reduce_time(self.getMeasuredSubFramePeriod())
 
     """
-    ------------------<<<Jungfrau specific>>>-------------------------
+    Jungfrau specific
     """
 
-    @property
-    @element
-    def chipversion(self):
-        """
-        [Jungfrau] Chip version of module. Can be 1.0 or 1.1.
-
-        Example
-        -------
-        >>> d.chipversion
-        '1.0'
-        """
-        return self.getChipVersion()
-
-
     @property
     @element
     def auto_comp_disable(self):
@@ -2032,39 +1981,14 @@ class Detector(CppDetectorApi):
 
         Note
         -----
-        By default, the on-chip gain switching is active during the entire exposure. This mode disables the on-chip gain switching comparator automatically after 93.75% of exposure time (only for longer than 100us). The % is only for chipv1.0, the duration can be set for chipv1.1.\n
+        By default, the on-chip gain switching is active during the entire exposure. This mode disables the on-chip gain switching comparator automatically after 93.75% of exposure time (only for longer than 100us).\n
         Default is 0 or this mode disabled (comparator enabled throughout). 1 enables mode. 0 disables mode. 
         """
-        return self.getAutoComparatorDisable()
+        return self.getAutoCompDisable()
 
     @auto_comp_disable.setter
     def auto_comp_disable(self, value):
-        ut.set_using_dict(self.setAutoComparatorDisable, value)
+        ut.set_using_dict(self.setAutoCompDisable, value)
-
-    @property
-    @element
-    def comp_disable_time(self):
-        """[Jungfrau] Time before end of exposure when comparator is disabled. 
-
-        Note
-        -----
-        It is only possible for chipv1.1.
-        :getter: always returns in seconds. To get in datetime.delta, use getComparatorDisableTime
-
-        Example
-        -----------
-        >>> d.comp_disable_time = 1.05
-        >>> d.comp_disable_time = datetime.timedelta(minutes = 3, seconds = 1.23)
-        >>> d.comp_disable_time
-        181.23
-        >>> d.getComparatorDisableTime()
-        [datetime.timedelta(seconds=181, microseconds=230000)]
-        """
-        return ut.reduce_time(self.getComparatorDisableTime())
-
-    @comp_disable_time.setter
-    def comp_disable_time(self, value):
-       ut.set_time_using_dict(self.setComparatorDisableTime, value)
 
 
     @property
@@ -2084,7 +2008,7 @@ class Detector(CppDetectorApi):
         [Jungfrau] Number of additional storage cells. 
         Note
         ----
-        Only for chip v1.0. For advanced users only. \n
+        For advanced users only. \n
         Options: 0 - 15. Default is 0.
         The #images = #frames x #triggers x (#storagecells + 1)
         """
@@ -2103,7 +2027,7 @@ class Detector(CppDetectorApi):
         Note
         ----
         For advanced users only.
-        Options 0-max. max is 15 (default) for chipv1.0 and 3 (default) for chipv1.1. \n
+        Options 0-15. Default is 15. \n
         """
         return self.getStorageCellStart()
 
@@ -2117,7 +2041,7 @@ class Detector(CppDetectorApi):
         [Jungfrau] Additional time delay between 2 consecutive exposures in burst mode, accepts either a value in seconds or datetime.timedelta
         Note
         -----
-        Only applicable for chipv1.0. For advanced users only \n
+        For advanced users only \n
         Value: 0-1638375 ns (resolution of 25ns) \n
         :getter: always returns in seconds. To get in datetime.delta, use getStorageCellDelay
 
@@ -2209,40 +2133,6 @@ class Detector(CppDetectorApi):
     def selinterface(self, i):
         ut.set_using_dict(self.selectUDPInterface, i)
 
-    @property
-    def gainmodelist(self):
-        """List of gainmode implemented for this detector."""
-        return self.getGainModeList()
-
-    @property
-    def gainmode(self):
-        """
-        [Jungfrau] Detector gain mode. Enum: gainMode
-        Note
-        -----
-        [Jungfrau] DYNAMIC, FORCE_SWITCH_G1, FORCE_SWITCH_G2, FIX_G1, FIX_G2, FIX_G0 \n
-        CAUTION: Do not use FIX_G0 without caution, you can damage the detector!!!
-        """
-        return element_if_equal(self.getGainMode())
-
-    @gainmode.setter
-    def gainmode(self, value):
-        self.setGainMode(value)
-
-    @property
-    @element
-    def currentsource(self):
-        """
-        Pass in a currentSrcParameters object
-        see python/examples/use_currentsource.py
-
-        """
-        return self.getCurrentSource()
-
-    @currentsource.setter
-    def currentsource(self, cs):
-        ut.set_using_dict(self.setCurrentSource, cs)
-
     """
     ---------------------------<<<Gotthard2 specific>>>---------------------------
     """
@@ -2271,37 +2161,18 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def filterresistor(self):
+    def filter(self):
-        """
+        """[Gotthard2] Set filter resistor. 
-        [Gotthard2][Jungfrau] Set filter resistor. Increasing values for increasing "
-        "resistance.
         Note
         ----
-        Advanced user command.
+        Default is 0. Options: 0-3.
-        [Gotthard2] Default is 0. Options: 0-3.
-        [Jungfrau] Default is 1. Options: 0-1.
         """
-        return self.getFilterResistor()
+        return self.getFilter()
 
-    @filterresistor.setter
+    @filter.setter
-    def filterresistor(self, value):
+    def filter(self, value):
-        ut.set_using_dict(self.setFilterResistor, value)
+        ut.set_using_dict(self.setFilter, value)
 
-    @property
-    @element
-    def filtercell(self):
-        """
-        [Jungfrau] Set filter capacitor. 
-        Note
-        ----
-        [Jungfrau] Options: 0-12. Default: 0. Advanced user command. Only for chipv1.1.
-        """
-        return self.getFilterCell()
-
-    @filtercell.setter
-    def filtercell(self, value):
-        ut.set_using_dict(self.setFilterCell, value)
-        
     @property
     def maxclkphaseshift(self):
         """
@@ -2341,7 +2212,7 @@ class Detector(CppDetectorApi):
     @element
     def veto(self):
         """
-        [Gotthard2] Enable or disable veto data from chip. 
+        [Gotthard2] Enable or disable veto data streaming from detector. 
         Note
         ----
         Default is 0.
@@ -2461,49 +2332,6 @@ class Detector(CppDetectorApi):
         ut.set_using_dict(self.setVetoReference, *args)
 
 
-    @property
-    @element
-    def vetostream(self):
-        """[Gotthard2] Enabling/ disabling veto interface
-        Note
-        ----
-        Default: both off
-        Options: NONE, LOW_LATENCY_LINK, 10GBE (debugging)
-        Debugging interface also enables second interface in receiver (separate file), which also restarts zmq streaming if enabled.
-        """
-        return self.getVetoStream()
-
-    @vetostream.setter
-    def vetostream(self, args):
-        if not isinstance(args, tuple):
-            args = (args,)
-        ut.set_using_dict(self.setVetoStream, *args)
-
-    @property
-    def vetoalg(self):
-        """[Gotthard2] Algorithm used for veto. Enum: vetoAlgorithm, streamingInterface
-        Note
-        ----
-        Options:
-        (vetoAlgorithm): ALG_HITS (default), ALG_RAW
-        (streamingInterface): ETHERNET_10GB, LOW_LATENCY_LINK
-        Example
-        ----------
-        >>> d.vetoalg = defs.ALG_HITS, defs.ETHERNET_10GB
-        """
-        result = {}
-        interface = [streamingInterface.LOW_LATENCY_LINK, streamingInterface.ETHERNET_10GB]
-        for eth in interface:
-            result[eth] = element_if_equal(self.getVetoAlgorithm(eth))
-        return result
-
-
-    @vetoalg.setter
-    def vetoalg(self, args):
-        if not isinstance(args, tuple):
-            args = (args,)
-        ut.set_using_dict(self.setVetoAlgorithm, *args)
-
     """
     Mythen3 specific
     """
@@ -2553,7 +2381,6 @@ class Detector(CppDetectorApi):
         Note
         -----
         Each element in list can be 0 - 2 and must be non repetitive.
-        Enabling counters sets vth dacs to remembered values and disabling sets them to disabled values.
 
         Example
         -----------
@@ -2694,12 +2521,7 @@ class Detector(CppDetectorApi):
     @property
     @element
     def dbitpipeline(self):
-        """[Ctb][Gotthard2] Pipeline of the clock for latching digital bits. 
+        """[Ctb] Pipeline of the clock for latching digital bits. """
-        Note
-        ----
-        [CTB] Options: 0 - 255
-        [Gotthard2] Options: 0 - 7
-        """
         return self.getDBITPipeline()
 
     @dbitpipeline.setter

python/slsdet/enums.py

@@ -1,20 +1,17 @@
-"""
-Automatically improt all enums from slsDetectorDefs and give an
-alias with their name in the enum module. All names from the enum
-module is later imported into slsdet
-
-Example: detectorType = _slsdet.slsDetectorDefs.detectorType
-Usage can later be:
-
-from slsdet import detectorType
-if dt === detectorType.EIGER:
-    #do something
-
-"""
-
 
 import _slsdet
-for name, cls in _slsdet.slsDetectorDefs.__dict__.items():
+runStatus = _slsdet.slsDetectorDefs.runStatus
-    if isinstance(cls, type):
+speedLevel = _slsdet.slsDetectorDefs.speedLevel
-        exec(f'{name} = {cls.__module__}.{cls.__qualname__}')
+detectorType = _slsdet.slsDetectorDefs.detectorType
-
+frameDiscardPolicy = _slsdet.slsDetectorDefs.frameDiscardPolicy
+fileFormat = _slsdet.slsDetectorDefs.fileFormat
+dimension = _slsdet.slsDetectorDefs.dimension
+externalSignalFlag = _slsdet.slsDetectorDefs.externalSignalFlag
+timingMode = _slsdet.slsDetectorDefs.timingMode
+dacIndex = _slsdet.slsDetectorDefs.dacIndex
+detectorSettings = _slsdet.slsDetectorDefs.detectorSettings
+clockIndex = _slsdet.slsDetectorDefs.clockIndex
+readoutMode = _slsdet.slsDetectorDefs.readoutMode
+masterFlags = _slsdet.slsDetectorDefs.masterFlags
+burstMode = _slsdet.slsDetectorDefs.burstMode
+timingSourceType = _slsdet.slsDetectorDefs.timingSourceType

python/slsdet/utils.py

@@ -41,7 +41,7 @@ def list_to_bitmask(values):
     return mask
 
 def make_bitmask(args):
-    if isinstance(args, (list,tuple)):
+    if isinstance(args, list):
         return list_to_bitmask(args)
     elif isinstance(args, dict):
         return {key: list_to_bitmask(value) for key, value in args.items()}

python/src/current.cpp

@@ -1,26 +0,0 @@
-#include <pybind11/chrono.h>
-#include <pybind11/numpy.h>
-#include <pybind11/operators.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-
-// #include "sls/Pattern.h"
-#include "sls/ToString.h"
-#include "sls/sls_detector_defs.h"
-
-namespace py = pybind11;
-void init_source(py::module &m) {
-
-    using src = slsDetectorDefs::currentSrcParameters;
-    py::class_<src> currentSrcParameters(m, "currentSrcParameters");
-
-    currentSrcParameters.def(py::init());
-    currentSrcParameters.def_readwrite("enable", &src::enable);
-    currentSrcParameters.def_readwrite("fix", &src::fix);
-    currentSrcParameters.def_readwrite("normal", &src::normal);
-    currentSrcParameters.def_readwrite("select", &src::select);
-    currentSrcParameters.def(pybind11::self == pybind11::self);
-
-    currentSrcParameters.def("__repr__",
-                             [](const src &a) { return sls::ToString(a); });
-}

python/src/detector.cpp

@@ -69,10 +69,6 @@ void init_det(py::module &m) {
              (Result<int64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getSerialNumber,
              py::arg() = Positions{})
-        .def("getModuleId",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getModuleId,
-             py::arg() = Positions{})
         .def("getReceiverVersion",
              (Result<int64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getReceiverVersion,
@@ -160,13 +156,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(const bool)) &
                  Detector::setGapPixelsinCallback,
              py::arg())
-        .def("getFlipRows",
-             (Result<bool>(Detector::*)(sls::Positions) const) &
-                 Detector::getFlipRows,
-             py::arg() = Positions{})
-        .def("setFlipRows",
-             (void (Detector::*)(bool, sls::Positions)) & Detector::setFlipRows,
-             py::arg(), py::arg() = Positions{})
         .def("isVirtualDetectorServer",
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::isVirtualDetectorServer,
@@ -254,17 +243,14 @@ void init_det(py::module &m) {
         .def("getTimingModeList",
              (std::vector<defs::timingMode>(Detector::*)() const) &
                  Detector::getTimingModeList)
-        .def("getReadoutSpeed",
+        .def("getSpeed",
              (Result<defs::speedLevel>(Detector::*)(sls::Positions) const) &
-                 Detector::getReadoutSpeed,
+                 Detector::getSpeed,
              py::arg() = Positions{})
-        .def("setReadoutSpeed",
+        .def("setSpeed",
              (void (Detector::*)(defs::speedLevel, sls::Positions)) &
-                 Detector::setReadoutSpeed,
+                 Detector::setSpeed,
              py::arg(), py::arg() = Positions{})
-        .def("getReadoutSpeedList",
-             (std::vector<defs::speedLevel>(Detector::*)() const) &
-                 Detector::getReadoutSpeedList)
         .def("getADCPhase",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getADCPhase,
@@ -368,28 +354,9 @@ void init_det(py::module &m) {
              py::arg(), py::arg() = Positions{})
         .def("getDacList", (std::vector<defs::dacIndex>(Detector::*)() const) &
                                Detector::getDacList)
-        .def("getDefaultDac",
+        .def("setDefaultDacs",
-             (Result<int>(Detector::*)(defs::dacIndex, sls::Positions)) &
+             (void (Detector::*)(sls::Positions)) & Detector::setDefaultDacs,
-                 Detector::getDefaultDac,
+             py::arg() = Positions{})
-             py::arg(), py::arg() = Positions{})
-        .def("setDefaultDac",
-             (void (Detector::*)(defs::dacIndex, int, sls::Positions)) &
-                 Detector::setDefaultDac,
-             py::arg(), py::arg(), py::arg() = Positions{})
-        .def("getDefaultDac",
-             (Result<int>(Detector::*)(defs::dacIndex, defs::detectorSettings,
-                                       sls::Positions)) &
-                 Detector::getDefaultDac,
-             py::arg(), py::arg(), py::arg() = Positions{})
-        .def("setDefaultDac",
-             (void (Detector::*)(defs::dacIndex, int, defs::detectorSettings,
-                                 sls::Positions)) &
-                 Detector::setDefaultDac,
-             py::arg(), py::arg(), py::arg(), py::arg() = Positions{})
-        .def("resetToDefaultDacs",
-             (void (Detector::*)(const bool, sls::Positions)) &
-                 Detector::resetToDefaultDacs,
-             py::arg(), py::arg() = Positions{})
         .def("getDAC",
              (Result<int>(Detector::*)(defs::dacIndex, bool, sls::Positions)
                   const) &
@@ -426,39 +393,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(bool, sls::Positions)) &
                  Detector::setParallelMode,
              py::arg(), py::arg() = Positions{})
-        .def("getFilterResistor",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getFilterResistor,
-             py::arg() = Positions{})
-        .def("setFilterResistor",
-             (void (Detector::*)(int, sls::Positions)) &
-                 Detector::setFilterResistor,
-             py::arg(), py::arg() = Positions{})
-        .def("getCurrentSource",
-             (Result<defs::currentSrcParameters>(Detector::*)(sls::Positions)
-                  const) &
-                 Detector::getCurrentSource,
-             py::arg() = Positions{})
-        .def("setCurrentSource",
-             (void (Detector::*)(defs::currentSrcParameters, sls::Positions)) &
-                 Detector::setCurrentSource,
-             py::arg(), py::arg() = Positions{})
-        .def("getDBITPipeline",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getDBITPipeline,
-             py::arg() = Positions{})
-        .def("setDBITPipeline",
-             (void (Detector::*)(int, sls::Positions)) &
-                 Detector::setDBITPipeline,
-             py::arg(), py::arg() = Positions{})
-        .def("getReadNRows",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getReadNRows,
-             py::arg() = Positions{})
-        .def("setReadNRows",
-             (void (Detector::*)(const int, sls::Positions)) &
-                 Detector::setReadNRows,
-             py::arg(), py::arg() = Positions{})
         .def("acquire", (void (Detector::*)()) & Detector::acquire)
         .def("clearAcquiringFlag",
              (void (Detector::*)()) & Detector::clearAcquiringFlag)
@@ -467,9 +401,7 @@ void init_det(py::module &m) {
         .def("startDetector", (void (Detector::*)()) & Detector::startDetector)
         .def("startDetectorReadout",
              (void (Detector::*)()) & Detector::startDetectorReadout)
-        .def("stopDetector",
+        .def("stopDetector", (void (Detector::*)()) & Detector::stopDetector)
-             (void (Detector::*)(sls::Positions)) & Detector::stopDetector,
-             py::arg() = Positions{})
         .def("getDetectorStatus",
              (Result<defs::runStatus>(Detector::*)(sls::Positions) const) &
                  Detector::getDetectorStatus,
@@ -496,9 +428,9 @@ void init_det(py::module &m) {
                  Detector::setNextFrameNumber,
              py::arg(), py::arg() = Positions{})
         .def("sendSoftwareTrigger",
-             (void (Detector::*)(const bool, sls::Positions)) &
+             (void (Detector::*)(sls::Positions)) &
                  Detector::sendSoftwareTrigger,
-             py::arg() = false, py::arg() = Positions{})
+             py::arg() = Positions{})
         .def("getScan",
              (Result<defs::scanParameters>(Detector::*)(sls::Positions) const) &
                  Detector::getScan,
@@ -559,31 +491,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(const sls::MacAddr, sls::Positions)) &
                  Detector::setSourceUDPMAC2,
              py::arg(), py::arg() = Positions{})
-        .def("getDestinationUDPList",
-             (Result<sls::UdpDestination>(Detector::*)(const uint32_t,
-                                                       sls::Positions) const) &
-                 Detector::getDestinationUDPList,
-             py::arg(), py::arg() = Positions{})
-        .def("setDestinationUDPList",
-             (void (Detector::*)(const sls::UdpDestination, const int)) &
-                 Detector::setDestinationUDPList,
-             py::arg(), py::arg())
-        .def("getNumberofUDPDestinations",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getNumberofUDPDestinations,
-             py::arg() = Positions{})
-        .def("clearUDPDestinations",
-             (void (Detector::*)(sls::Positions)) &
-                 Detector::clearUDPDestinations,
-             py::arg() = Positions{})
-        .def("getFirstUDPDestination",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getFirstUDPDestination,
-             py::arg() = Positions{})
-        .def("setFirstUDPDestination",
-             (void (Detector::*)(const int, sls::Positions)) &
-                 Detector::setFirstUDPDestination,
-             py::arg(), py::arg() = Positions{})
         .def("getDestinationUDPIP",
              (Result<sls::IpAddr>(Detector::*)(sls::Positions) const) &
                  Detector::getDestinationUDPIP,
@@ -920,6 +827,13 @@ void init_det(py::module &m) {
              (void (Detector::*)(bool, sls::Positions)) &
                  Detector::setOverFlowMode,
              py::arg(), py::arg() = Positions{})
+        .def("getBottom",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getBottom,
+             py::arg() = Positions{})
+        .def("setBottom",
+             (void (Detector::*)(bool, sls::Positions)) & Detector::setBottom,
+             py::arg(), py::arg() = Positions{})
         .def("getRateCorrection",
              (Result<sls::ns>(Detector::*)(sls::Positions) const) &
                  Detector::getRateCorrection,
@@ -932,6 +846,14 @@ void init_det(py::module &m) {
              (void (Detector::*)(sls::ns, sls::Positions)) &
                  Detector::setRateCorrection,
              py::arg(), py::arg() = Positions{})
+        .def("getPartialReadout",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getPartialReadout,
+             py::arg() = Positions{})
+        .def("setPartialReadout",
+             (void (Detector::*)(const int, sls::Positions)) &
+                 Detector::setPartialReadout,
+             py::arg(), py::arg() = Positions{})
         .def("getInterruptSubframe",
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::getInterruptSubframe,
@@ -956,6 +878,14 @@ void init_det(py::module &m) {
              (void (Detector::*)(const bool, sls::Positions)) &
                  Detector::setActive,
              py::arg(), py::arg() = Positions{})
+        .def("getRxPadDeactivatedMode",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getRxPadDeactivatedMode,
+             py::arg() = Positions{})
+        .def("setRxPadDeactivatedMode",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setRxPadDeactivatedMode,
+             py::arg(), py::arg() = Positions{})
         .def("getPartialReset",
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::getPartialReset,
@@ -981,20 +911,6 @@ void init_det(py::module &m) {
              py::arg() = Positions{})
         .def("setQuad", (void (Detector::*)(const bool)) & Detector::setQuad,
              py::arg())
-        .def("getDataStream",
-             (Result<bool>(Detector::*)(const defs::portPosition,
-                                        sls::Positions) const) &
-                 Detector::getDataStream,
-             py::arg(), py::arg() = Positions{})
-        .def("setDataStream",
-             (void (Detector::*)(const defs::portPosition, const bool,
-                                 sls::Positions)) &
-                 Detector::setDataStream,
-             py::arg(), py::arg(), py::arg() = Positions{})
-        .def("getChipVersion",
-             (Result<double>(Detector::*)(sls::Positions) const) &
-                 Detector::getChipVersion,
-             py::arg() = Positions{})
         .def("getThresholdTemperature",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getThresholdTemperature,
@@ -1019,21 +935,13 @@ void init_det(py::module &m) {
              (void (Detector::*)(sls::Positions)) &
                  Detector::resetTemperatureEvent,
              py::arg() = Positions{})
-        .def("getAutoComparatorDisable",
+        .def("getAutoCompDisable",
              (Result<bool>(Detector::*)(sls::Positions) const) &
-                 Detector::getAutoComparatorDisable,
+                 Detector::getAutoCompDisable,
              py::arg() = Positions{})
-        .def("setAutoComparatorDisable",
+        .def("setAutoCompDisable",
              (void (Detector::*)(bool, sls::Positions)) &
-                 Detector::setAutoComparatorDisable,
+                 Detector::setAutoCompDisable,
-             py::arg(), py::arg() = Positions{})
-        .def("getComparatorDisableTime",
-             (Result<sls::ns>(Detector::*)(sls::Positions) const) &
-                 Detector::getComparatorDisableTime,
-             py::arg() = Positions{})
-        .def("setComparatorDisableTime",
-             (void (Detector::*)(sls::ns, sls::Positions)) &
-                 Detector::setComparatorDisableTime,
              py::arg(), py::arg() = Positions{})
         .def("getNumberOfAdditionalStorageCells",
              (Result<int>(Detector::*)(sls::Positions) const) &
@@ -1059,25 +967,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(sls::ns, sls::Positions)) &
                  Detector::setStorageCellDelay,
              py::arg(), py::arg() = Positions{})
-        .def("getGainModeList",
-             (std::vector<defs::gainMode>(Detector::*)() const) &
-                 Detector::getGainModeList)
-        .def("getGainMode",
-             (Result<defs::gainMode>(Detector::*)(sls::Positions) const) &
-                 Detector::getGainMode,
-             py::arg() = Positions{})
-        .def("setGainMode",
-             (void (Detector::*)(const defs::gainMode, sls::Positions)) &
-                 Detector::setGainMode,
-             py::arg(), py::arg() = Positions{})
-        .def("getFilterCell",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getFilterCell,
-             py::arg() = Positions{})
-        .def("setFilterCell",
-             (void (Detector::*)(int, sls::Positions)) &
-                 Detector::setFilterCell,
-             py::arg(), py::arg() = Positions{})
         .def("getROI",
              (Result<defs::ROI>(Detector::*)(sls::Positions) const) &
                  Detector::getROI,
@@ -1153,6 +1042,21 @@ void init_det(py::module &m) {
         .def("setCDSGain",
              (void (Detector::*)(bool, sls::Positions)) & Detector::setCDSGain,
              py::arg(), py::arg() = Positions{})
+        .def("getFilter",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getFilter,
+             py::arg() = Positions{})
+        .def("setFilter",
+             (void (Detector::*)(int, sls::Positions)) & Detector::setFilter,
+             py::arg(), py::arg() = Positions{})
+        .def("getCurrentSource",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getCurrentSource,
+             py::arg() = Positions{})
+        .def("setCurrentSource",
+             (void (Detector::*)(bool, sls::Positions)) &
+                 Detector::setCurrentSource,
+             py::arg(), py::arg() = Positions{})
         .def("getTimingSource",
              (Result<defs::timingSourceType>(Detector::*)(sls::Positions)
                   const) &
@@ -1170,27 +1074,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(const bool, sls::Positions)) &
                  Detector::setVeto,
              py::arg(), py::arg() = Positions{})
-        .def("getVetoStream",
-             (Result<defs::streamingInterface>(Detector::*)(sls::Positions)
-                  const) &
-                 Detector::getVetoStream,
-             py::arg() = Positions{})
-        .def("setVetoStream",
-             (void (Detector::*)(const defs::streamingInterface,
-                                 sls::Positions)) &
-                 Detector::setVetoStream,
-             py::arg(), py::arg() = Positions{})
-        .def("getVetoAlgorithm",
-             (Result<defs::vetoAlgorithm>(Detector::*)(
-                 const defs::streamingInterface, sls::Positions) const) &
-                 Detector::getVetoAlgorithm,
-             py::arg(), py::arg() = Positions{})
-        .def("setVetoAlgorithm",
-             (void (Detector::*)(const defs::vetoAlgorithm,
-                                 const defs::streamingInterface,
-                                 sls::Positions)) &
-                 Detector::setVetoAlgorithm,
-             py::arg(), py::arg(), py::arg() = Positions{})
         .def("getADCConfiguration",
              (Result<int>(Detector::*)(const int, const int, sls::Positions)
                   const) &
@@ -1253,16 +1136,6 @@ void init_det(py::module &m) {
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::getMaster,
              py::arg() = Positions{})
-        .def("getChipStatusRegister",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getChipStatusRegister,
-             py::arg() = Positions{})
-        .def("setGainCaps",
-             (void (Detector::*)(int, sls::Positions)) & Detector::setGainCaps,
-             py::arg(), py::arg() = Positions{})
-        .def("getGainCaps",
-             (Result<int>(Detector::*)(sls::Positions)) & Detector::getGainCaps,
-             py::arg() = Positions{})
         .def("getNumberOfAnalogSamples",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getNumberOfAnalogSamples,
@@ -1344,6 +1217,14 @@ void init_det(py::module &m) {
         .def("setDBITClock",
              (void (Detector::*)(int, sls::Positions)) & Detector::setDBITClock,
              py::arg(), py::arg() = Positions{})
+        .def("getDBITPipeline",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getDBITPipeline,
+             py::arg() = Positions{})
+        .def("setDBITPipeline",
+             (void (Detector::*)(int, sls::Positions)) &
+                 Detector::setDBITPipeline,
+             py::arg(), py::arg() = Positions{})
         .def("getMeasuredVoltage",
              (Result<int>(Detector::*)(defs::dacIndex, sls::Positions) const) &
                  Detector::getMeasuredVoltage,

python/src/enums.cpp

@@ -210,9 +210,13 @@ void init_enums(py::module &m) {
         .value("LOWGAIN", slsDetectorDefs::detectorSettings::LOWGAIN)
         .value("MEDIUMGAIN", slsDetectorDefs::detectorSettings::MEDIUMGAIN)
         .value("VERYHIGHGAIN", slsDetectorDefs::detectorSettings::VERYHIGHGAIN)
-        .value("HIGHGAIN0", slsDetectorDefs::detectorSettings::HIGHGAIN0)
+        .value("DYNAMICHG0", slsDetectorDefs::detectorSettings::DYNAMICHG0)
         .value("FIXGAIN1", slsDetectorDefs::detectorSettings::FIXGAIN1)
         .value("FIXGAIN2", slsDetectorDefs::detectorSettings::FIXGAIN2)
+        .value("FORCESWITCHG1",
+               slsDetectorDefs::detectorSettings::FORCESWITCHG1)
+        .value("FORCESWITCHG2",
+               slsDetectorDefs::detectorSettings::FORCESWITCHG2)
         .value("VERYLOWGAIN", slsDetectorDefs::detectorSettings::VERYLOWGAIN)
         .value("G1_HIGHGAIN", slsDetectorDefs::detectorSettings::G1_HIGHGAIN)
         .value("G1_LOWGAIN", slsDetectorDefs::detectorSettings::G1_LOWGAIN)
@@ -226,7 +230,6 @@ void init_enums(py::module &m) {
                slsDetectorDefs::detectorSettings::G2_LOWCAP_LOWGAIN)
         .value("G4_HIGHGAIN", slsDetectorDefs::detectorSettings::G4_HIGHGAIN)
         .value("G4_LOWGAIN", slsDetectorDefs::detectorSettings::G4_LOWGAIN)
-        .value("GAIN0", slsDetectorDefs::detectorSettings::GAIN0)
         .value("UNDEFINED", slsDetectorDefs::detectorSettings::UNDEFINED)
         .value("UNINITIALIZED",
                slsDetectorDefs::detectorSettings::UNINITIALIZED)
@@ -250,8 +253,12 @@ void init_enums(py::module &m) {
         .value("FULL_SPEED", slsDetectorDefs::speedLevel::FULL_SPEED)
         .value("HALF_SPEED", slsDetectorDefs::speedLevel::HALF_SPEED)
         .value("QUARTER_SPEED", slsDetectorDefs::speedLevel::QUARTER_SPEED)
-        .value("G2_108MHZ", slsDetectorDefs::speedLevel::G2_108MHZ)
+        .export_values();
-        .value("G2_144MHZ", slsDetectorDefs::speedLevel::G2_144MHZ)
+
+    py::enum_<slsDetectorDefs::masterFlags>(Defs, "masterFlags")
+        .value("NO_MASTER", slsDetectorDefs::masterFlags::NO_MASTER)
+        .value("IS_MASTER", slsDetectorDefs::masterFlags::IS_MASTER)
+        .value("IS_SLAVE", slsDetectorDefs::masterFlags::IS_SLAVE)
         .export_values();
 
     py::enum_<slsDetectorDefs::burstMode>(Defs, "burstMode")
@@ -270,52 +277,4 @@ void init_enums(py::module &m) {
         .value("TIMING_EXTERNAL",
                slsDetectorDefs::timingSourceType::TIMING_EXTERNAL)
         .export_values();
-
-    py::enum_<slsDetectorDefs::M3_GainCaps>(Defs, "M3_GainCaps")
-        .value("M3_C10pre", slsDetectorDefs::M3_GainCaps::M3_C10pre)
-        .value("M3_C15sh", slsDetectorDefs::M3_GainCaps::M3_C15sh)
-        .value("M3_C30sh", slsDetectorDefs::M3_GainCaps::M3_C30sh)
-        .value("M3_C50sh", slsDetectorDefs::M3_GainCaps::M3_C50sh)
-        .value("M3_C225ACsh", slsDetectorDefs::M3_GainCaps::M3_C225ACsh)
-        .value("M3_C15pre", slsDetectorDefs::M3_GainCaps::M3_C15pre)
-        .export_values();
-
-    py::enum_<slsDetectorDefs::portPosition>(Defs, "portPosition")
-        .value("LEFT", slsDetectorDefs::portPosition::LEFT)
-        .value("RIGHT", slsDetectorDefs::portPosition::RIGHT)
-        .value("TOP", slsDetectorDefs::portPosition::TOP)
-        .value("BOTTOM", slsDetectorDefs::portPosition::BOTTOM)
-        .export_values();
-
-    py::enum_<slsDetectorDefs::streamingInterface>(Defs, "streamingInterface",
-                                                   py::arithmetic())
-        .value("NONE", slsDetectorDefs::streamingInterface::NONE)
-        .value("LOW_LATENCY_LINK",
-               slsDetectorDefs::streamingInterface::LOW_LATENCY_LINK)
-        .value("ETHERNET_10GB",
-               slsDetectorDefs::streamingInterface::ETHERNET_10GB)
-        .value("ALL", slsDetectorDefs::streamingInterface::ALL)
-        .export_values()
-        .def("__or__",
-             py::overload_cast<const slsDetectorDefs::streamingInterface &,
-                               const slsDetectorDefs::streamingInterface &>(
-                 &operator|))
-        .def("__and__",
-             py::overload_cast<const slsDetectorDefs::streamingInterface &,
-                               const slsDetectorDefs::streamingInterface &>(
-                 &operator&));
-
-    py::enum_<slsDetectorDefs::vetoAlgorithm>(Defs, "vetoAlgorithm")
-        .value("ALG_HITS", slsDetectorDefs::vetoAlgorithm::ALG_HITS)
-        .value("ALG_RAW", slsDetectorDefs::vetoAlgorithm::ALG_RAW)
-        .export_values();
-
-    py::enum_<slsDetectorDefs::gainMode>(Defs, "gainMode")
-        .value("DYNAMIC", slsDetectorDefs::gainMode::DYNAMIC)
-        .value("FORCE_SWITCH_G1", slsDetectorDefs::gainMode::FORCE_SWITCH_G1)
-        .value("FORCE_SWITCH_G2", slsDetectorDefs::gainMode::FORCE_SWITCH_G2)
-        .value("FIX_G1", slsDetectorDefs::gainMode::FIX_G1)
-        .value("FIX_G2", slsDetectorDefs::gainMode::FIX_G2)
-        .value("FIX_G0", slsDetectorDefs::gainMode::FIX_G0)
-        .export_values();
 }

python/src/main.cpp

@@ -21,7 +21,6 @@ void init_det(py::module &);
 void init_network(py::module &);
 void init_pattern(py::module &);
 void init_scan(py::module &);
-void init_source(py::module &);
 PYBIND11_MODULE(_slsdet, m) {
     m.doc() = R"pbdoc(
         C/C++ API
@@ -38,7 +37,6 @@ PYBIND11_MODULE(_slsdet, m) {
      init_network(m);
      init_pattern(m);
      init_scan(m);
-     init_source(m);
     //  init_experimental(m);
     
 

serverBin/ctbDetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer

serverBin/ctbDetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServerv6.0.0-rc1

serverBin/eigerDetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer

serverBin/eigerDetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServerv6.0.0-rc1

serverBin/gotthard2DetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer

serverBin/gotthard2DetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServerv6.0.0-rc1

serverBin/gotthardDetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer

serverBin/gotthardDetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServerv6.0.0-rc1

serverBin/jungfrauDetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer

serverBin/jungfrauDetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServerv6.0.0-rc1

serverBin/moenchDetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer

serverBin/moenchDetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServerv6.0.0-rc1

serverBin/mythen3DetectorServer_developer

@@ -0,0 +1 @@
+../slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer

serverBin/mythen3DetectorServerv6.0.0-rc1

@@ -1 +0,0 @@
-../slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServerv6.0.0-rc1

slsDetectorCalibration/circularFifo.h

@@ -1,156 +0,0 @@
-#pragma once
-/* CircularFifo.h 
-* Code & platform dependent issues with it was originally
-* published at http://www.kjellkod.cc/threadsafecircularqueue
-* 2009-11-02
-* @author Kjell Hedstr<74>m, hedstrom@kjellkod.cc
-* modified by the sls detetor group
-* */
-
-//#include "sls_receiver_defs.h"
-#include <semaphore.h>
-#include <vector>
-#include <iostream>
-
-typedef  double double32_t;
-typedef  float float32_t;
-typedef  int int32_t;
-
-
-
-/** Circular Fifo (a.k.a. Circular Buffer)
-* Thread safe for one reader, and one writer */
-template<typename Element>
-class CircularFifo {
-public:
-
-   CircularFifo(unsigned int Size) : tail(0), head(0){
-	   Capacity = Size + 1;
-	   array.resize(Capacity);
-	   sem_init(&data_mutex,0,0);
-	   sem_init(&free_mutex,0,Size);
-   }
-   virtual ~CircularFifo() {
-       sem_destroy(&data_mutex);
-	   sem_destroy(&free_mutex);
-   }
-
-   bool push(Element*& item_, bool no_block=false);
-   bool pop(Element*& item_, bool no_block=false);
-
-   bool isEmpty() const;
-   bool isFull() const;
-
-   int getDataValue() const;
-   int getFreeValue() const;
-
-private:
-   std::vector <Element*> array;
-   unsigned int tail; // input index
-   unsigned int head; // output index
-   unsigned int Capacity;
-   mutable sem_t data_mutex;
-   mutable sem_t free_mutex;
-   unsigned int increment(unsigned int idx_) const;
-};
-
-template<typename Element>
-int CircularFifo<Element>::getDataValue() const
-{
-   int value;
-   sem_getvalue(&data_mutex, &value);
-   return value;
-}
-
-template<typename Element>
-int CircularFifo<Element>::getFreeValue() const
-{
-    int value;
-    sem_getvalue(&free_mutex, &value);
-    return value;
-}
-
-
-/** Producer only: Adds item to the circular queue.
-* If queue is full at 'push' operation no update/overwrite
-* will happen, it is up to the caller to handle this case
-*
-* \param item_ copy by reference the input item
-* \param no_block if true, return immediately if fifo is full
-* \return whether operation was successful or not */
-template<typename Element>
-bool CircularFifo<Element>::push(Element*& item_, bool no_block)
-{
-    // check for fifo full
-    if (no_block && isFull())
-        return false;
-
-    sem_wait(&free_mutex);
-    array[tail] = item_;
-    tail = increment(tail);
-    sem_post(&data_mutex);
-    return true;
-}
-
-/** Consumer only: Removes and returns item from the queue
-* If queue is empty at 'pop' operation no retrieve will happen
-* It is up to the caller to handle this case
-*
-* \param item_ return by reference the wanted item
-* \param no_block if true, return immediately if fifo is full
-* \return whether operation was successful or not */
-template<typename Element>
-bool CircularFifo<Element>::pop(Element*& item_, bool no_block)
-{
-    // check for fifo empty
-    if (no_block && isEmpty())
-        return false;
-
-   sem_wait(&data_mutex);
-   item_ = array[head];
-   head = increment(head);
-   sem_post(&free_mutex);
-   return true;
-}
-
-/** Useful for testinng and Consumer check of status
-  * Remember that the 'empty' status can change quickly
-  * as the Procuder adds more items.
-  *
-  * \return true if circular buffer is empty */
-template<typename Element>
-bool CircularFifo<Element>::isEmpty() const
-{
-    return (getDataValue() == 0);
-}
-
-/** Useful for testing and Producer check of status
-  * Remember that the 'full' status can change quickly
-  * as the Consumer catches up.
-  *
-  * \return true if circular buffer is full.  */
-template<typename Element>
-bool CircularFifo<Element>::isFull() const
-{
-    return (getFreeValue() == 0);
-}
-
-/** Increment helper function for index of the circular queue
-* index is inremented or wrapped
-*
-*  \param idx_ the index to the incremented/wrapped
-*  \return new value for the index */
-template<typename Element>
-unsigned int CircularFifo<Element>::increment(unsigned int idx_) const
-{
-   // increment or wrap
-   // =================
-   //    index++;
-   //    if(index == array.lenght) -> index = 0;
-   //
-   //or as written below:
-   //    index = (index+1) % array.length
-   idx_ = (idx_+1) % Capacity;
-   return idx_;
-}
-

slsDetectorCalibration/dataStructures/jungfrauHighZSingleChipData.h

@@ -1,238 +0,0 @@
-#ifndef JUNGFRAUHIGHZSINGLECHIPDATA_H
-#define  JUNGFRAUHIGHZSINGLECHIPDATA_H
-#include "slsDetectorData.h"
-
-//#define VERSION_V2
-    /**
-        @short  structure for a Detector Packet or Image Header
-        @li frameNumber is the frame number
-        @li expLength is the subframe number (32 bit eiger) or real time exposure time in 100ns (others)
-        @li packetNumber is the packet number
-        @li bunchId is the bunch id from beamline
-        @li timestamp is the time stamp with 10 MHz clock
-        @li modId is the unique module id (unique even for left, right, top, bottom)
-        @li xCoord is the x coordinate in the complete detector system
-        @li yCoord is the y coordinate in the complete detector system
-        @li zCoord is the z coordinate in the complete detector system
-        @li debug is for debugging purposes
-        @li roundRNumber is the round robin set number
-        @li detType is the detector type see :: detectorType
-        @li version is the version number of this structure format
-    */
-    typedef struct {
-        uint64_t bunchNumber;    /**< is the frame number */
-        uint64_t pre;    /**< something */
-
-    } jf_header;
-
-
-
-
-class jungfrauHighZSingleChipData : public slsDetectorData<uint16_t> {
- 
- private:
-  
-  int iframe;
- public:
-  /**
-     Implements the slsReceiverData structure for the moench02 prototype read out by a module i.e. using the slsReceiver
-     (160x160 pixels, 40 packets 1286 large etc.)
-     \param c crosstalk parameter for the output buffer
-
-  */
- jungfrauHighZSingleChipData(): slsDetectorData<uint16_t>(256, 256, 256*256*2+sizeof(jf_header)) {
-
-
-     for (int ix=0; ix<256; ix++) {
-       for (int iy=0; iy<256; iy++) {
-	 dataMap[iy][ix]=sizeof(jf_header)+(256*iy+ix)*2;
-#ifdef HIGHZ
-	 dataMask[iy][ix]=0x3fff;
-#endif
-	 }
-     }
-    
-    iframe=0;
-    //  cout << "data struct created" << endl;
-  };
-    
-
- 
-  /**
-     Returns the value of the selected channel for the given dataset as double.
-     \param data pointer to the dataset (including headers etc)
-     \param ix pixel number in the x direction
-     \param iy pixel number in the y direction
-     \returns data for the selected channel, with inversion if required as double
-
-  */
-  virtual double getValue(char *data, int ix, int iy=0) {
-   
-    uint16_t val=getChannel(data, ix, iy)&0x3fff;
-    return val;
-  };
-
-   
-
-  /* virtual void calcGhost(char *data, int ix, int iy) { */
-  /*   double val=0; */
-  /*   ghost[iy][ix]=0; */
-    
-  /* } */
-
-
-
-  /* virtual void calcGhost(char *data) { */
-  /*   for (int ix=0; ix<25; ix++){ */
-  /*     for (int iy=0; iy<200; iy++) { */
-  /* 	calcGhost(data, ix,iy); */
-  /*     }  */
-  /*   } */
-  /*   // cout << "*" << endl; */
-  /* } */
-
-
-  /* double getGhost(int ix, int iy) { */
-  /*   return 0; */
-  /* }; */
-
-     /**
-
-     Returns the frame number for the given dataset. Purely virtual func.
-     \param buff pointer to the dataset
-     \returns frame number
-
-  */
-
-/* class jfrau_packet_header_t { */
-/*  public: */
-/* 	unsigned char reserved[4]; */
-/* 	unsigned char packetNumber[1]; */
-/* 	unsigned char frameNumber[3]; */
-/* 	unsigned char bunchid[8]; */
-/* }; */
-
-
-
-  int getFrameNumber(char *buff){return ((jf_header*)buff)->bunchNumber;};//*((int*)(buff+5))&0xffffff;};   
-
-  /**
-
-     Returns the packet number for the given dataset. purely virtual func
-     \param buff pointer to the dataset
-     \returns packet number number
-
-
-
-  */
-   int getPacketNumber(char *buff){return 0;}//((*(((int*)(buff+4))))&0xff)+1;};   
-
-/*    /\** */
-
-/*      Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func */
-/*      \param data pointer to the memory to be analyzed */
-/*      \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot */
-/*      \param dsize size of the memory slot to be analyzed */
-/*      \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found  */
-
-/*   *\/ */
-/*     virtual  char *findNextFrame(char *data, int &ndata, int dsize){ndata=dsize; setDataSize(dsize);  return data;}; */
-
-
-/*    /\** */
-
-/*      Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors!  */
-/*      \param filebin input file stream (binary) */
-/*      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete */
-
-/*   *\/ */
-/*     virtual char *readNextFrame(ifstream &filebin){ */
-/*       //	int afifo_length=0;   */
-/*       uint16_t *afifo_cont;  */
-/*       int ib=0; */
-/*       if (filebin.is_open()) { */
-/* 	afifo_cont=new uint16_t[dataSize/2]; */
-/*  	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
-/* 	  ib+=2; */
-/* 	  if (ib==dataSize) break; */
-/* 	} */
-/* 	if (ib>0) { */
-/* 	  iframe++; */
-/* 	  // cout << ib << "-" << endl; */
-/* 	  return (char*)afifo_cont; */
-/* 	} else { */
-/* 	  delete [] afifo_cont; */
-/* 	  return NULL; */
-/* 	} */
-/*       }      */
-/*       return NULL; */
-/*     }; */
-
-
-  virtual char *readNextFrame(ifstream &filebin) {
-    int ff=-1, np=-1;
-    return readNextFrame(filebin, ff, np);
-  };
-
-  virtual char *readNextFrame(ifstream &filebin, int &ff) {
-    int np=-1;
-    return readNextFrame(filebin, ff, np);
-  };
-
-  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np) {
-	  char *data=new char[dataSize];
-	  char *d=readNextFrame(filebin, ff, np, data);
-	  if (d==NULL) {delete [] data; data=NULL;}
-	  return data;
-  }
-
-
-
-
-  virtual char *readNextFrame(ifstream &filebin, int& ff, int &np, char *data) {
-	  char *retval=0;
-	  int  nd;
-	  int fnum = -1;
-	  np=0;
-	  int  pn;
-	  
-	  //  cout << dataSize << endl;
-	  if (ff>=0)
-	    fnum=ff;
-
-	  if (filebin.is_open()) {
-	    if (filebin.read(data, dataSize) ){
-	      ff=getFrameNumber(data);
-	      np=getPacketNumber(data);
-	      return data;
-	    }
-	  }
-	  return NULL;
-  };
-
-
-
-  /**
-
-     Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func
-     \param data pointer to the memory to be analyzed
-     \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot
-     \param dsize size of the memory slot to be analyzed
-     \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found 
-     
-  */
-  virtual  char *findNextFrame(char *data, int &ndata, int dsize){
-    if (dsize<dataSize) ndata=dsize;
-    else ndata=dataSize;
-    return data;
-
-  }
-
-  //int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
-
-};
-
-
-
-
-#endif

slsDetectorCalibration/dataStructures/moench03T1ZmqDataNew.h

@@ -14,8 +14,6 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
   const int nSamples;
   const int offset;
 
-
-
   double ghost[200][25];
   double xtalk;
 
@@ -31,22 +29,17 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 
   */
   // moench03T1ZmqDataNew(int ns=5000): slsDetectorData<uint16_t>(400, 400, ns*32*2+sizeof(int)), nSamples(ns), offset(sizeof(int)), xtalk(0.00021) {
- moench03T1ZmqDataNew(int ns=5000, int oo=2*2): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
+ moench03T1ZmqDataNew(int ns=5000, int oo=0): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
-    cout << "M0.3" << endl;
+
     int nadc=32;
     int sc_width=25;
     int sc_height=200;
-    
+
-     int adc_nr[32]={300,325,350,375,300,325,350,375,	\
+    int adc_nr[32]={300,325,350,375,300,325,350,375,		\
     		    200,225,250,275,200,225,250,275,\
     		    100,125,150,175,100,125,150,175,\
     		    0,25,50,75,0,25,50,75};
-   
+
-     /*   int adc_nr[32]={350,375,150,175,350,375,150,175,	\
-    		    300,325,100,125,300,325,100,125,\
-    		    250,275,50,75,250,275,50,75,\
-    		    200,225,0,25,200,225,0,25};
-     */
     int row, col;
     
     int isample;
@@ -57,11 +50,11 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
     int i;
     int adc4(0);
   
-    //for (int ip=0; ip<npackets; ip++) {
+    for (int ip=0; ip<npackets; ip++) {
-    // for (int is=0; is<128; is++) {
+      for (int is=0; is<128; is++) {
-    for (i=0; i<nSamples; i++) {
+
 	for (iadc=0; iadc<nadc; iadc++) {
-	  //i=128*ip+is;
+	  i=128*ip+is;
 	  adc4=(int)iadc/4;
 	  if (i<sc_width*sc_height) {
 	    //  for (int i=0; i<sc_width*sc_height; i++) {
@@ -77,7 +70,7 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 	  }
 	}
       }
-  // }
+    }
 
     
     int ii=0;

slsDetectorCalibration/energyCalibration.cpp

@@ -1,798 +0,0 @@
-#include "energyCalibration.h"
-
-#ifdef __CINT
-#define MYROOT
-#endif
-
-
-#ifdef MYROOT
-#include <TMath.h>
-#include <TH1F.h>
-#include <TH2F.h>
-#include <TGraphErrors.h>
-#endif
-
-#include <iostream>
-
-#define max(a,b) ((a) > (b) ? (a) : (b))
-#define min(a,b) ((a) < (b) ? (a) : (b))
-#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }
-
-
-using namespace std;
-
-#ifdef MYROOT
-
-Double_t energyCalibrationFunctions::pedestal(Double_t *x, Double_t *par) { 
-    return par[0]-par[1]*sign*x[0];                                      
-}
-
-
-Double_t energyCalibrationFunctions::gaussChargeSharing(Double_t *x, Double_t *par) { 
-  Double_t f, arg=0;
-  // Gaussian exponent
-  if (par[3]!=0) {
-    arg=sign*(x[0]-par[2])/par[3];
-  }
-  // the Gaussian
-  f=TMath::Exp(-1*arg*arg/2.); 
-  // Gaussian + error function
-  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
-  // Gaussian + error function + pedestal
-  return par[4]*f+pedestal(x,par);                                       
-}
-
-Double_t energyCalibrationFunctions::gaussChargeSharingKb(Double_t *x, Double_t *par) { 
-  Double_t f, arg=0,argb=0;
-  // Gaussian exponent
-  if (par[3]!=0) {
-    arg=sign*(x[0]-par[2])/par[3];
-    argb=sign*(x[0]-(par[6]*par[2]))/par[3]; // using absolute kb mean might seem better but like this the ratio can be fixed
-  }
-  // the Gaussian
-  f=TMath::Exp(-1*arg*arg/2.); 
-  f=f+par[7]*(TMath::Exp(-1*argb*argb/2.));
-  // Gaussian + error function
-  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
-  f=f+par[7]*par[5]/2.*(TMath::Erfc(argb/(TMath::Sqrt(2.)))); 
-  // Gaussian + error function + pedestal
-  return par[4]*f+pedestal(x,par);                                       
-}
-
-Double_t energyCalibrationFunctions::gaussChargeSharingKaDoublet(Double_t *x, Double_t *par) { 
-  Double_t f, f2, arg=0, arg2=0;
-  // Gaussian exponent
-  if (par[3]!=0) {
-    arg=sign*(x[0]-par[2])/par[3];
-    arg2=sign*(x[0]-par[6])/par[3];
-  }
-  // the Gaussian
-  f=TMath::Exp(-1*arg*arg/2.); 
-  f2=TMath::Exp(-1*arg2*arg2/2.); 
-  // Gaussian + error function
-  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
-  f2=f2+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); // shouldn't this be arg2?
-  // Gaussian + error function + pedestal
-  return par[4]*f+par[7]*f2+pedestal(x,par);                                       
-}
-
-Double_t energyCalibrationFunctions::gaussChargeSharingPixel(Double_t *x, Double_t *par) { 
-  Double_t f;
-  if (par[3]<=0 || par[2]*(*x)<=0 || par[5]<0 || par[4]<=0) return 0;
-
-  Double_t pp[3];
-
-  pp[0]=0;
-  pp[1]=par[2];
-  pp[2]=par[3];
-  
-
-  f=(par[5]-par[6]*(TMath::Log(*x/par[2])))*erfBox(x,pp);
-  f+=par[4]*TMath::Gaus(*x, par[2], par[3], kTRUE);
-  return f+pedestal(x,par);                                       
-}
-
-Double_t energyCalibrationFunctions::erfBox(Double_t *z, Double_t *par) {
-
-  
-  
-  Double_t m=par[0];
-  Double_t M=par[1];
-  
-  if (par[0]>par[1]) {
-    m=par[1];
-    M=par[0];
-  }
-  
-  if (m==M)
-    return 0;
-
-
-  if (par[2]<=0) {
-    if (*z>=m && *z<=M)
-      return 1./(M-m);
-    else
-      return 0;
-
-  }
-
-  return (TMath::Erfc((z[0]-M)/par[2])-TMath::Erfc((z[0]-m)/par[2]))*0.5/(M-m);
-
-}
-
-
-// basic erf function
-Double_t energyCalibrationFunctions::erfFunction(Double_t *x, Double_t *par) {	
-  double arg=0;
-  if (par[1]!=0) arg=(par[0]-x[0])/par[1];
-  return ((par[2]/2.*(1+TMath::Erf(sign*arg/(TMath::Sqrt(2))))));  
-};
-  
-
-Double_t energyCalibrationFunctions::erfFunctionChargeSharing(Double_t *x, Double_t *par) {	       
-  Double_t f;		
-  
-  f=erfFunction(x, par+2)*(1+par[5]*(par[2]-x[0]))+par[0]-par[1]*x[0]*sign;		
-  return f;								
-};
-  
-  
-Double_t energyCalibrationFunctions::erfFuncFluo(Double_t *x, Double_t *par) {
-  Double_t f;							       
-  f=erfFunctionChargeSharing(x, par)+erfFunction(x, par+6)*(1+par[9]*(par[6]-x[0])); 
-  return f;							
-};
-#endif
-
-double energyCalibrationFunctions::median(double *x, int n){
-  // sorts x into xmed array and returns median 
-  // n is number of values already in the xmed array
-  double xmed[n];
-  int k,i,j;
-
-  for (i=0; i<n; i++) {
-    k=0;
-    for (j=0; j<n; j++) {
-      if(*(x+i)>*(x+j))
-	k++;
-      if (*(x+i)==*(x+j)) {
-	if (i>j) 
-	  k++;
-      }
-    }
-    xmed[k]=*(x+i);
-  }
-  k=n/2;
-  return xmed[k];
-}
-
-
-int energyCalibrationFunctions::quick_select(int arr[], int n){
-    int low, high ;
-    int median;
-    int middle, ll, hh;
-
-    low = 0 ; high = n-1 ; median = (low + high) / 2;
-    for (;;) {
-        if (high <= low) /* One element only */
-            return arr[median] ;
-
-        if (high == low + 1) {  /* Two elements only */
-            if (arr[low] > arr[high])
-                ELEM_SWAP(arr[low], arr[high]) ;
-            return arr[median] ;
-        }
-
-    /* Find median of low, middle and high items; swap into position low */
-    middle = (low + high) / 2;
-    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
-    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
-    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;
-
-    /* Swap low item (now in position middle) into position (low+1) */
-    ELEM_SWAP(arr[middle], arr[low+1]) ;
-
-    /* Nibble from each end towards middle, swapping items when stuck */
-    ll = low + 1;
-    hh = high;
-    for (;;) {
-        do ll++; while (arr[low] > arr[ll]) ;
-        do hh--; while (arr[hh]  > arr[low]) ;
-
-        if (hh < ll)
-        break;
-
-        ELEM_SWAP(arr[ll], arr[hh]) ;
-    }
-
-    /* Swap middle item (in position low) back into correct position */
-    ELEM_SWAP(arr[low], arr[hh]) ;
-
-    /* Re-set active partition */
-    if (hh <= median)
-        low = ll;
-        if (hh >= median)
-        high = hh - 1;
-    }
-}
-
-int energyCalibrationFunctions::kth_smallest(int *a, int n, int k){
-    register int i,j,l,m ;
-    register double x ;
-
-    l=0 ; m=n-1 ;
-    while (l<m) {
-        x=a[k] ;
-        i=l ;
-        j=m ;
-        do {
-            while (a[i]<x) i++ ;
-            while (x<a[j]) j-- ;
-            if (i<=j) {
-                ELEM_SWAP(a[i],a[j]) ;
-                i++ ; j-- ;
-            }
-        } while (i<=j) ;
-        if (j<k) l=i ;
-        if (k<i) m=j ;
-    }
-    return a[k] ;
-}
-
-
-
-#ifdef MYROOT
-Double_t energyCalibrationFunctions::spectrum(Double_t *x, Double_t *par) {
-  return gaussChargeSharing(x,par);	
-}
-
-Double_t energyCalibrationFunctions::spectrumkb(Double_t *x, Double_t *par) {
-  return gaussChargeSharingKb(x,par);	
-}
-
-Double_t energyCalibrationFunctions::spectrumkadoublet(Double_t *x, Double_t *par) {
-  return gaussChargeSharingKaDoublet(x,par);	
-}
-
-Double_t energyCalibrationFunctions::spectrumPixel(Double_t *x, Double_t *par) {
-  return gaussChargeSharingPixel(x,par);	
-}
-
-
-Double_t energyCalibrationFunctions::scurve(Double_t *x, Double_t *par) {
-  return erfFunctionChargeSharing(x,par);
-}
-
-
-Double_t energyCalibrationFunctions::scurveFluo(Double_t *x, Double_t *par) {
-  return erfFuncFluo(x,par);						
-}
-#endif
-
-energyCalibration::energyCalibration() : 
-#ifdef MYROOT	
-					 fit_min(-1),	
-					 fit_max(-1),	
-					 bg_offset(-1),	
-					 bg_slope(-1),	
-					 flex(-1),
-					 noise(-1),
-					 ampl(-1),
-					 cs_slope(-1),
-					 kb_mean(-1),
-					 kb_frac(-1),
-					 mean2(-1),
-					 ampl2(-1),
-					 fscurve(NULL),
-					 fspectrum(NULL),
-					 fspectrumkb(NULL),
-					 fspectrumkadoublet(NULL),
-#endif
-					 funcs(NULL),
-					 plot_flag(1), // fit parameters output to screen
-					 cs_flag(1)
-{
-
-#ifdef MYROOT	
-  funcs=new energyCalibrationFunctions();
-  
-  fscurve=new TF1("fscurve",funcs,&energyCalibrationFunctions::scurve,0,1000,6,"energyCalibrationFunctions","scurve");	
-  fscurve->SetParNames("Background Offset","Background Slope","Inflection Point","Noise RMS", "Number of Photons","Charge Sharing Slope");
-
-  fspectrum=new TF1("fspectrum",funcs,&energyCalibrationFunctions::spectrum,0,1000,6,"energyCalibrationFunctions","spectrum");	
-  fspectrum->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal");
-  fspectrumkb=new TF1("fspectrumkb",funcs,&energyCalibrationFunctions::spectrumkb,0,1000,8,"energyCalibrationFunctions","spectrumkb");	
-  fspectrumkb->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","kb mean","kb frac");
-
-  fspectrumkadoublet=new TF1("fspectrumkadoublet",funcs,&energyCalibrationFunctions::spectrumkadoublet,0,1000,8,"energyCalibrationFunctions","spectrumkadoublet");	
-  fspectrumkadoublet->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","ka2 mean","n2");
-
-  fspixel=new TF1("fspixel",funcs,&energyCalibrationFunctions::spectrumPixel,0,1000,7,"energyCalibrationFunctions","spectrumPixel");	
-  fspixel->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","Corner");
-
-#endif
-
-
-}
-
-
-
-void energyCalibration::fixParameter(int ip, Double_t val){
-  
-  fscurve->FixParameter(ip, val);
-  fspectrum->FixParameter(ip, val);
-  fspectrumkb->FixParameter(ip, val);
-  fspectrumkadoublet->FixParameter(ip, val);
-}
-
-
-void energyCalibration::releaseParameter(int ip){
-
-  fscurve->ReleaseParameter(ip);
-  fspectrum->ReleaseParameter(ip);
-  fspectrumkb->ReleaseParameter(ip);
-  fspectrumkadoublet->ReleaseParameter(ip);
-}
-
-
-
-
-
-
-
-energyCalibration::~energyCalibration(){ 
-#ifdef MYROOT
-  delete fscurve;
-  delete fspectrum;
-  delete fspectrumkb;
-  delete fspectrumkadoublet;
-#endif
-  
-}
-
-#ifdef MYROOT
-
-
-
-
-
-TH1F* energyCalibration::createMedianHistogram(TH2F* h2, int ch0, int nch, int direction) {
-
-  if (h2==NULL || nch==0)
-    return NULL;
-
-  double *x=new double[nch];
-  TH1F *h1=NULL;
-  
-  double val=-1;
-
-  if (direction==0) {
-    h1=new TH1F("median","Median",h2->GetYaxis()->GetNbins(),h2->GetYaxis()->GetXmin(),h2->GetYaxis()->GetXmax());
-    for (int ib=0; ib<h1->GetXaxis()->GetNbins(); ib++) {
-      for (int ich=0; ich<nch; ich++) {
-	x[ich]=h2->GetBinContent(ch0+ich+1,ib+1);
-      }
-      val=energyCalibrationFunctions::median(x, nch);
-      h1->SetBinContent(ib+1,val);
-    }
-  } else if (direction==1) {   
-    h1=new TH1F("median","Median",h2->GetXaxis()->GetNbins(),h2->GetXaxis()->GetXmin(),h2->GetXaxis()->GetXmax());
-    for (int ib=0; ib<h1->GetYaxis()->GetNbins(); ib++) {
-      for (int ich=0; ich<nch; ich++) {
-	x[ich]=h2->GetBinContent(ib+1,ch0+ich+1);
-      }
-      val=energyCalibrationFunctions::median(x, nch);
-      h1->SetBinContent(ib+1,val);
-    }
-  }
-  delete [] x;
-
-  return h1;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-void energyCalibration::setStartParameters(Double_t *par){	
-  bg_offset=par[0];						
-  bg_slope=par[1];						
-  flex=par[2];							
-  noise=par[3];							
-  ampl=par[4];							
-  cs_slope=par[5];						
-}
-
-void energyCalibration::setStartParametersKb(Double_t *par){	
-  bg_offset=par[0];						
-  bg_slope=par[1];						
-  flex=par[2];							
-  noise=par[3];							
-  ampl=par[4];							
-  cs_slope=par[5];						
-  kb_mean=par[6];
-  kb_frac=par[7];
-  //fit_min = 400; // used for soleil flat field
-  //fit_max = 800;
-}
-
-void energyCalibration::setStartParametersKaDoublet(Double_t *par){	
-  bg_offset=par[0];						
-  bg_slope=par[1];						
-  flex=par[2];							
-  noise=par[3];							
-  ampl=par[4];							
-  cs_slope=par[5];						
-  mean2=par[6];
-  ampl2=par[7];
-  //fit_min = 400; // used for soleil flat field
-  //fit_max = 800;
-}
-
-
-void energyCalibration::getStartParameters(Double_t *par){	
-  par[0]=bg_offset;
-  par[1]=bg_slope;
-  par[2]=flex;
-  par[3]=noise;
-  par[4]=ampl;				
-  par[5]=cs_slope;				
-}
-
-#endif
-int energyCalibration::setChargeSharing(int p) {
-  if (p>=0) {
-    cs_flag=p; 
-#ifdef MYROOT  
-    if (p) {
-      fscurve->ReleaseParameter(5);
-      fspectrum->ReleaseParameter(1);
-      fspectrumkb->ReleaseParameter(1);
-      fspectrumkadoublet->ReleaseParameter(1);
-    } else {
-      fscurve->FixParameter(5,0);
-      fspectrum->FixParameter(1,0);
-      fspectrumkb->FixParameter(1,0);
-      fspectrumkadoublet->FixParameter(1,0);
-    }
-#endif
-  } 
-  
-  return cs_flag;
-}
-
- 
-#ifdef MYROOT  
-void energyCalibration::initFitFunction(TF1 *fun, TH1 *h1) {
-
- Double_t min=fit_min, max=fit_max; 
-
- Double_t mypar[6];
-  
- if (max==-1) 
-    max=h1->GetXaxis()->GetXmax();
- 
-  if (min==-1) 
-    min=h1->GetXaxis()->GetXmin();
-
-  
-  if (bg_offset==-1)
-    mypar[0]=0;
-  else
-    mypar[0]=bg_offset;
-
-
-  if (bg_slope==-1)
-    mypar[1]=0;
-  else
-    mypar[1]=bg_slope;
-
-
-  if (flex==-1)
-    mypar[2]=(min+max)/2.;
-  else
-    mypar[2]=flex;
-
-
-  if (noise==-1)
-    mypar[3]=0.1;
-  else
-    mypar[3]=noise;
-
-  if (ampl==-1)
-    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
-  else
-    mypar[4]=ampl;
-
-  if (cs_slope==-1)
-    mypar[5]=0;
-  else
-    mypar[5]=cs_slope;
- 
-  fun->SetParameters(mypar);
-
-  fun->SetRange(min,max);
-
-}
-
-void energyCalibration::initFitFunctionKb(TF1 *fun, TH1 *h1) {
-
- Double_t min=fit_min, max=fit_max; 
-
- Double_t mypar[8];
-  
- if (max==-1) 
-    max=h1->GetXaxis()->GetXmax();
- 
-  if (min==-1) 
-    min=h1->GetXaxis()->GetXmin();
-
-  
-  if (bg_offset==-1)
-    mypar[0]=0;
-  else
-    mypar[0]=bg_offset;
-
-
-  if (bg_slope==-1)
-    mypar[1]=0;
-  else
-    mypar[1]=bg_slope;
-
-
-  if (flex==-1)
-    mypar[2]=(min+max)/2.;
-  else
-    mypar[2]=flex;
-
-
-  if (noise==-1)
-    mypar[3]=0.1;
-  else
-    mypar[3]=noise;
-
-  if (ampl==-1)
-    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
-  else
-    mypar[4]=ampl;
-
-  if (cs_slope==-1)
-    mypar[5]=0;
-  else
-    mypar[5]=cs_slope;
-
-  if (kb_mean==-1)
-    mypar[6]=0;
-  else
-    mypar[6]=kb_mean;
-
-  if (kb_frac==-1)
-    mypar[7]=0;
-  else
-    mypar[7]=kb_frac;
- 
-  fun->SetParameters(mypar);
-
-  fun->SetRange(min,max);
-
-}
-
-void energyCalibration::initFitFunctionKaDoublet(TF1 *fun, TH1 *h1) {
-
- Double_t min=fit_min, max=fit_max; 
-
- Double_t mypar[8];
-  
- if (max==-1) 
-    max=h1->GetXaxis()->GetXmax();
- 
-  if (min==-1) 
-    min=h1->GetXaxis()->GetXmin();
-
-  
-  if (bg_offset==-1)
-    mypar[0]=0;
-  else
-    mypar[0]=bg_offset;
-
-
-  if (bg_slope==-1)
-    mypar[1]=0;
-  else
-    mypar[1]=bg_slope;
-
-
-  if (flex==-1)
-    mypar[2]=(min+max)/2.;
-  else
-    mypar[2]=flex;
-
-
-  if (noise==-1)
-    mypar[3]=0.1;
-  else
-    mypar[3]=noise;
-
-  if (ampl==-1)
-    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
-  else
-    mypar[4]=ampl;
-
-  if (cs_slope==-1)
-    mypar[5]=0;
-  else
-    mypar[5]=cs_slope;
-
-  if (mean2==-1)
-    mypar[6]=0;
-  else
-    mypar[6]=mean2;
-
-  if (ampl2==-1)
-    mypar[7]=0;
-  else
-    mypar[7]=ampl2;
- 
-  fun->SetParameters(mypar);
-
-  fun->SetRange(min,max);
-
-}
-
-TF1* energyCalibration::fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
-
-
-  TF1* fitfun;
-
-  char fname[100];
-
-  strcpy(fname, fun->GetName());
-
-  if (plot_flag) {
-    h1->Fit(fname,"R0Q");
-  } else
-    h1->Fit(fname,"R0Q");
-
-  fitfun= h1->GetFunction(fname);
-  fitfun->GetParameters(mypar);
-  for (int ip=0; ip<6; ip++) {
-    emypar[ip]=fitfun->GetParError(ip);
-  }
-  return fitfun;
-}
-
-TF1* energyCalibration::fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
-
-
-  TF1* fitfun;
-
-  char fname[100];
-
-  strcpy(fname, fun->GetName());
-
-  if (plot_flag) {
-    h1->Fit(fname,"R0Q");
-  } else
-    h1->Fit(fname,"R0Q");
-
-  fitfun= h1->GetFunction(fname);
-  fitfun->GetParameters(mypar);
-  for (int ip=0; ip<8; ip++) {
-    emypar[ip]=fitfun->GetParError(ip);
-  }
-  return fitfun;
-}
-
-TF1* energyCalibration::fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
-
-
-  TF1* fitfun;
-
-  char fname[100];
-
-  strcpy(fname, fun->GetName());
-
-  if (plot_flag) {
-    h1->Fit(fname,"R0Q");
-  } else
-    h1->Fit(fname,"R0Q");
-
-
-  fitfun= h1->GetFunction(fname);
-  fitfun->GetParameters(mypar);
-  for (int ip=0; ip<8; ip++) {
-    emypar[ip]=fitfun->GetParError(ip);
-  }
-  return fitfun;
-}
-
-TF1* energyCalibration::fitSCurve(TH1 *h1, Double_t *mypar, Double_t *emypar) {
-  initFitFunction(fscurve,h1);
-  return fitFunction(fscurve, h1, mypar, emypar);
-}
-
-
-
-
-
-TF1* energyCalibration::fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar) {
-  initFitFunction(fspectrum,h1);
-  return fitFunction(fspectrum, h1, mypar, emypar);
-}
-
-TF1* energyCalibration::fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar) {
-  initFitFunctionKb(fspectrumkb,h1);
-  return fitFunctionKb(fspectrumkb, h1, mypar, emypar);
-}
-
-TF1* energyCalibration::fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar) {
-  initFitFunctionKaDoublet(fspectrumkadoublet,h1);
-  return fitFunctionKaDoublet(fspectrumkadoublet, h1, mypar, emypar);
-}
-
-
-TGraphErrors* energyCalibration::linearCalibration(int nscan, Double_t *en, Double_t *een, Double_t *fl, Double_t *efl, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff) { 
- 
-  TGraphErrors *gr;
- 
-  Double_t  mypar[2];
- 
-  gr = new TGraphErrors(nscan,en,fl,een,efl);
-
-  if (plot_flag) {
-    gr->Fit("pol1");
-    gr->SetMarkerStyle(20);
-  } else
-    gr->Fit("pol1","0Q");
-        
-  TF1 *fitfun= gr->GetFunction("pol1"); 
-  fitfun->GetParameters(mypar);
-
-  egain=fitfun->GetParError(1);
-  eoff=fitfun->GetParError(0);
-
-  gain=funcs->setScanSign()*mypar[1];
-  
-  off=mypar[0]; 
-  
-  return gr;
-}
-
-
-TGraphErrors* energyCalibration::calibrate(int nscan, Double_t *en, Double_t *een, TH1F **h1, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff, int integral) {
-
-  TH1F *h;
-
-  Double_t mypar[6], emypar[6];
-  Double_t fl[nscan], efl[nscan];
-  
-
-  for (int ien=0; ien<nscan; ien++) {
-    h=h1[ien];
-    if (integral)
-      fitSCurve(h,mypar,emypar);
-    else
-      fitSpectrum(h,mypar,emypar);
-
-    fl[ien]=mypar[2];
-    efl[ien]=emypar[2];
-  }
-  return linearCalibration(nscan,en,een,fl,efl,gain,off, egain, eoff);
-
-}
-
-#endif
-
-
-
-

slsDetectorCalibration/energyCalibration.h

@@ -98,8 +98,6 @@ class energyCalibrationFunctions {
       par[5] is the fractional height of the charge sharing pedestal (scales with par[3])
   */
   Double_t gaussChargeSharing(Double_t *x, Double_t *par);
-  Double_t gaussChargeSharingKb(Double_t *x, Double_t *par);
-  Double_t gaussChargeSharingKaDoublet(Double_t *x, Double_t *par);
   /** 
       Gaussian Function with charge sharing pedestal
       par[0] is the absolute height of the background pedestal
@@ -155,8 +153,6 @@ Double_t erfFuncFluo(Double_t *x, Double_t *par);
       par[5] is the fractional height of the charge sharing pedestal (scales with par[4]
   */
   Double_t spectrum(Double_t *x, Double_t *par);
-  Double_t spectrumkb(Double_t *x, Double_t *par);
-  Double_t spectrumkadoublet(Double_t *x, Double_t *par);
 
   /** 
       static function Gaussian with charge sharing pedestal with the correct scan sign
@@ -289,9 +285,7 @@ class energyCalibration  {
       par[5] is the angual coefficient of the charge sharing slope (scales with par[3]) -- always positive
   */
   void setStartParameters(Double_t *par);
-  void setStartParametersKb(Double_t *par);
+  
-  void setStartParametersKaDoublet(Double_t *par);
-
 /** get start parameters for the s-curve function
     \param par parameters, -1 means auto-calculated
       par[0] is the  pedestal 
@@ -321,8 +315,16 @@ class energyCalibration  {
      \returns the fitted function - can be used e.g. to get the Chi2 or similar
   */
   TF1 *fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar);
-  TF1 *fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar);
+
-  TF1 *fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar);
+
+  /**
+     fits histogram with the spectrum
+     \param h1 1d-histogram to be fitted
+     \param mypar pointer to fit parameters array 
+     \param emypar pointer to fit parameter errors
+     \returns the fitted function - can be used e.g. to get the Chi2 or similar
+  */
+  TF1 *fitSpectrumPixel(TH1 *h1, Double_t *mypar, Double_t *emypar);
 
 
   /**
@@ -397,8 +399,6 @@ class energyCalibration  {
 */
   
   void initFitFunction(TF1 *fun, TH1 *h1);
-  void initFitFunctionKb(TF1 *fun, TH1 *h1);
-  void initFitFunctionKaDoublet(TF1 *fun, TH1 *h1);
 
 
   /**
@@ -410,8 +410,6 @@ class energyCalibration  {
      \returns the fitted function - can be used e.g. to get the Chi2 or similar
   */
   TF1 *fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
-  TF1 *fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
-  TF1 *fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
 
 #endif
 
@@ -425,16 +423,11 @@ class energyCalibration  {
   Double_t noise; /**< start value for the noise */
   Double_t ampl; /**< start value for the number of photons */
   Double_t cs_slope; /**< start value for the charge sharing slope */
-  Double_t kb_mean;
+
-  Double_t kb_frac;
-  Double_t mean2;
-  Double_t ampl2;
 
   TF1 *fscurve; /**< function with which the s-curve will be fitted */
 
   TF1 *fspectrum; /**< function with which the spectrum will be fitted */
-  TF1 *fspectrumkb; /**< function with which the spectrum will be fitted */
-  TF1 *fspectrumkadoublet; /**< function with which the spectrum will be fitted */
 
   TF1 *fspixel; /**< function with which the spectrum will be fitted */