release txt fix

Jfcalib

.clang-tidy

@@ -18,7 +18,8 @@ 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

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.12)
 project(slsDetectorPackage)
-set(PROJECT_VERSION 5.0.0)
+set(PROJECT_VERSION 5.1.0)
 include(CheckIPOSupported)
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 
@@ -32,13 +32,16 @@ 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_TEXTCLIENT "Text Client" ON)
-option (SLS_USE_RECEIVER "Receiver" ON)
-option (SLS_USE_GUI "GUI" OFF)
-option (SLS_USE_SIMULATOR "Simulator" OFF)
-option (SLS_USE_TESTS "TESTS" OFF)
-option (SLS_USE_INTEGRATION_TESTS "Integration Tests" 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_DETECTOR "Detector libs" ON)
+option(SLS_USE_RECEIVER "Receiver" ON)
+option(SLS_USE_RECEIVER_BINARIES "Receiver binaries" ON)
+option(SLS_USE_GUI "GUI" 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)
@@ -93,6 +96,20 @@ 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")
@@ -157,8 +174,37 @@ 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()
@@ -171,9 +217,9 @@ endif(SLS_USE_TESTS)
 # Common functionallity to detector and receiver
 add_subdirectory(slsSupportLib)
 
-if (SLS_USE_TEXTCLIENT)
+if (SLS_USE_DETECTOR OR SLS_USE_TEXTCLIENT)
     add_subdirectory(slsDetectorSoftware)
-endif (SLS_USE_TEXTCLIENT)
+endif ()
 
 if (SLS_USE_RECEIVER)
     add_subdirectory(slsReceiverSoftware) 
@@ -192,7 +238,7 @@ if (SLS_USE_INTEGRATION_TESTS)
 endif (SLS_USE_INTEGRATION_TESTS)
 
 if (SLS_USE_PYTHON)
-    set(PYBIND11_CPP_STANDARD -std=c++11)
+    find_package (Python 3.6 COMPONENTS Interpreter Development)
     add_subdirectory(libs/pybind11)
     add_subdirectory(python)
 endif(SLS_USE_PYTHON)

LICENSE

@@ -0,0 +1,674 @@
+                    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

@@ -0,0 +1,165 @@
+                   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,7 +4,11 @@ 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
-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).
+##### 5.0.0 - Latest Release
+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. 
@@ -45,7 +49,7 @@ These are mainly aimed at those not familiar with using ccmake and cmake.
 ```
     The binaries are generated in slsDetectorPackage/build/bin directory.
 
-    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>]
+    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>]
     -[no option]: only make
     -c: Clean
     -b: Builds/Rebuilds CMake files normal mode
@@ -65,6 +69,7 @@ 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 -?
@@ -90,3 +95,8 @@ 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,325 +1,326 @@
-SLS Detector Package 5.0.0 released on 18.11.2020 (Major Release)
-=================================================================
+SLS Detector Package 6.0.0-rc1 released on 08.10.2021 (Release Candidate 1)
+===========================================================================
+
+This document describes the differences between v6.0.0-rc1 and v5.1.0.   
+
+
 
     CONTENTS
     --------
-    1.	Topics Concerning
-    2.  New Features
-    3.  Resolved Issues
-    4.  Known Issues
-    5.  Firmware Requirements
-    6.  Download, Documentation & Support
+    1.  New or Changed Features
+    2.  Resolved Issues
+    3.  Known Issues
+    4.  Firmware Requirements
+    5.  Download, Documentation & Support
 
 
 
-1. Topics Concerning
-====================
 
-    - Compilation requirements
-    - Manuals
-    - Client API complete change
-    - Exceptions
-    - Scan mode (dacs and trimbit)
-    - Timing commands
-    - Enum list (daclist, dacvalues, settingslist, drlist etc.)
-    - Command line (return code)
-    - Command line (dac)
-    - UDP configuration change
-    - Gappixels
-    - Detector Simulators
-    - (Jungfrau server) settings and default dacs
-    - (Servers) Shared Memory
-    - (Jungfrau) two interfaces
-    - (Eiger, Jungfrau server) starting frame number
-    - (Eiger server) Server Config File
-    - (Eiger server) Partial Readout
-    - (Eiger server) Removed Features
-    - (Eiger server) Deactivation
-    - Zmq interface (ZmqSocket.h)
-    - slsReceiver (Metadata)
-    - slsReceiver (Shared Memory)
-    - slsReceiver (UDP IP)
-    - (Eiger Custom Receiver) Header packet
-    - Gui (zmq high water mark)
-    - (Eiger Server) Blocked server
-    - (Eiger Firmware) Extra 8 byte Packets
- 
+1. New or Changed Features
+==========================
 
-
-2. New Features
-===============
-
-    Client
+    Client 
     ------
-    1.  Compilation requirements
-        They are very different now and can be accessed at
-            https://slsdetectorgroup.github.io/devdoc/dependencies.html
-        Gui not included in default cmk.sh script. Must be explicitly asked for.
 
-    2.  Manuals 
-        They can be compiled in the package. 
-            https://slsdetectorgroup.github.io/devdoc/installation.html#build-this-documentation
-        Or refer to the documentation provided in 
-            https://slsdetectorgroup.github.io/devdoc/index.html
-
-    3.  API
-        Changed to Detector class. 
-        C++: Detector.h
-            Documentation:
-                https://slsdetectorgroup.github.io/devdoc/detector.html
-            Examples to use the Detector class:
-                https://github.com/slsdetectorgroup/api-examples
-
-        Python API Documentation: 
-            https://slsdetectorgroup.github.io/devdoc/pydetector.html
-
-        Command line:
-            Many commands have become deprecated. They will still execute, 
-            but give a warning.
-            Documentation:
-                https://slsdetectorgroup.github.io/devdoc/commandline.html
-            Help on a command:
-                sls_detector_help [command], or
-                sls_detector_get -h [command]
+    1.  [Jungfrau] Chip version 
+        Features for chipv1.1 incorporated
+        Command line: chipversion, API: getchipVersion 
+        gets chip version (1.0 or 1.1)
+        chipv1.1 requires config_jungfrau.txt on detector server.
     
-    4.  Exceptions
-        They are thrown instead of providing error codes.
-            sls_detector_exceptions.h
-        Make sure you catch all exceptions in custom gui and handle them or 
-        inform the user.
-        Exceptions thrown in callbacks are also handled.
-            - An exception in startAcquisitionCallBack will need to be handled in 
-            startReceiver or acquire()
-            - An exception in acquisitionFinishedCallBack will need to be handled in
-            stopReceiver or acquire()
-            - An exception in rawDataReadyCallBack or rawDataModifyReadyCallBack
-            will only print and skip image to free it in memory. If address is
-            incorrect after callback, expect undefined behavior.
+    2.  [Jungfrau] Chip configuration (only chipv1.1)
+        powering on the chip and changing settings will configure the chip.
+        Hence, required before acquisition.
 
-    5.  Scan mode
-        One can do scans for dacs or trimbits. Trimbits are only for Eiger or 
-        Mythen3. Enable scan mode and then acquire using blocking or non blocking
-        method. Command: scan.
+    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)
 
-    6.  Timing Commands
-        In command line, all timing commands (eg. peiod) can now specify unit. 
-            eg 100ms 10us, 1s, 100ns
-        In C++ API, one must use chrono library.
-            eg. std::chrono::duration<double, std::milli> t1{232.57};
-                det.setExptime(std::chrono::duration_cast<std::chrono::nanoseconds>(t1));
-        In Python API, one must use timedelta library. 
-            eg. d.exptime = dt.timedelta(seconds = 1.2)
+    4.  [Jungfrau] Storage cells (only chipv1.1)
+        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.
 
-    7.  Enum list (daclist)
-        Command line and API now has features to get the list of enums/commands
-        for dacs, settings, dynamic range, timing modes and temperatures for 
-        the detector in shared memory. 
-            eg. daclist, settingslist, drlist, timinglist, templist
-        Command line also has commands to get their values.
-            eg. dacvalues, tempvalues
-        Python has commands to get their values (detector specific class).
-            eg. d.temp, d.dacs
+    6.  [Jungfrau] Filter cell (only chipv1.1)
+        Command line: filtercell, API: getFilterCell/ setFilterCell
+        Set filter cell. Options: [0-12]. Advanced user command.
 
-    8.  Command Line (return code)
-        Return code of the client command line applications now return 0 for 
-        success and 1 for failure.
+    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.
         
-    9.  Command Line (Dac)
-        All dac commands have been converted to a single "dac" command with 
-        the previous dac commands as arguments.
-            eg. sls_detector_get vcmp_ll
-            is now
-            sls_detector_get dac vcmp_ll
+    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.
     
-    10. UDP Configuration
-        Once all the udp details are set in the detector, the detector's
-        destination is then configured automatically. If the detector is not 
-        configured, it will  fail when acquiring. If any of these parameters
-        are also changed, then this is configured again. Hence, configuremac 
-        command has been removed. Instead, there are commands such as
-        udp_validate (to validate if it has been configured) and
-        udp_reconfigure (to reconfigure).
+    18. [Gotthard2]
+        Command line: dbitpipeline, API: getDBITPipeline/ setDBITPipeline 
+        Set pipeline to latch digital bits. Options: 0-7
 
-    11. Gap Pixels
-        Gap pixels are now only available in client call back or gui (not in 
-        receiver anymore). It can be enabled for Eiger and Jungfrau and 
-        includes inter chip and inter module gap pixels.
+    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.
 
-    Detector Servers
+        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.  Detector Simulators 
-        Or virtual detector servers for every detector have been provided. 
-        They are compiled along with the client by enabling its option. 
-        They should also send fake data (increasing pixel/channel value).  
+    1.  [Gotthard2] Bad Channels moved to a new register, default settings 
+        including clock frequency changed
 
-    2.  (Jungfrau) settings
-        Settings command do not implicitly set default dacs from now on.
-        One can use the command 'defaultdacs' to set them explicitly.
+    2.  [Gotthard2] Updated config file in detector server
+    
 
-    3.  Shared Memory
-        Almost all the detector parameters removed from shared memory.
-        Therefore, they are all fetched directly from detector.
+    Virtual servers
+    ----------------
 
-    4.  (Jungfrau) Two 10G data interfaces
-        Only Jungfrau PCBs with version 2.0 can run at full speed using both
-        the 10G UDP interfaces to stream out data. This is available from 
-        the current firmware and software. To enable two interfaces, one has 
-        to enable two interfaces using "numinterfaces" to 2 and set corresponding
-        udp_dstip2, udp_dstport2 etc. One can also decide to select which of 
-        the two interfaces to use, when using only 1 interface.
+    1.  Artifical pixel values increasing by every packet, instead of every pixel.
 
-    5.  (Eiger, Jungfrau) Next Frame number
-        Both now have running frame numbers that is only reset at boot up
-        and increments continuously through acquisitions. One is able to 
-        set the next frame number now. Command: nextframenumber.
+    2.  All possible features updated.
 
-    6.  (Eiger) Server Config file (config_eiger.txt)
-        A config file on the detector can take in 2 parameters "master" 
-        and "top" being set to 1 or 0 to enable or disable the same.
-        When server is started without this file, it is set to hardware
-        settings.
-
-    7.  (Eiger) Partial readout
-        It is possible for partial readouts, where you specify the number
-        of pixel rows to read out. Not all values are allowed. The current
-        slsReceiver does not complain about missing packets, but only puts 
-        this partial image into the complete image (padding the rest). One
-        can cut out required subimage using callbacks, but this feature
-        is probably more useful for custom receivers. Command: readnlines.
-
-    8.  (Eiger) Removed Features
-        storeinram, safe speed and ability to set settings via the settings 
-        command has been removed.
-
-    9.  (Eiger) Deactivation
-        The detector is deactivated by default upon boot up and activated only 
-        upon setting hostname in the client. This is to ensure if the 
-        network of a board or a board is broken and one cannot connect
-        to this board, then it is deactivated by default upon reboot. 
-        Therefore, one can use other half modules of the detector.
 
     Receiver
     --------
 
-    1.  Zmq
-        The static library and the zmq.h is no longer provided with package.
-        One must install ZeroMQ version 4.
-        ZmqSocket.h API has changed, especially in parsing receiving JSON header.
-        One must pick up needed parameters  from exposed struct zmqHeader in 
-        ZmqSocket.h.
+    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.  Metadata
-        Detector dependant metadata has been added to the master files.
+    2.  Removed Padding option for Deactivated half modules.
 
-    3.  Shared Memory
-        Almost all receiver parameters have been removed from client shared memory.
-        Therefore the receiver process needs to be alive to access any receiver
-        parameter as they are now fetched directly from the receiver.
-
-    4.  UDP IP
-        Since all the parameters are fetched from receiver or detector directly 
-        (not shared memory), the udp desintation ip (previously rx_udpip) is safer 
-        to be specified before setting rx_hostname. Setting it before has the
-        advantage that the detector is updated first before the receiver is
-        requested for the udp mac. This helps when changing pc and the receiver
-        cannot find the udp ip to get the udp mac.
-
-    5.  (Eiger) Header packet
-        The header packets of Eiger are not sent in this firmware version. So, 
-        custom receivers should handle accordingly.
+    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.  Zmq high water mark
-        When opening the Gui, the zmq send and receiver high water mark is set to 2
-        instead of default (1000 for zmq library version 4). This is to ensure
-        fast and large detectors can still see latest data on the gui at the cost of
-        losing images in between.
-        When using a different processor or client data call back to handle zmq data, 
-        please ensure this is set back to default to get every zmq packet. Setting it to 
-        -1 sets it to library defaults.
+    ----
 
-    
-    
+    1. [Mythen3] counters added in settings tab
 
-3. Resolved Issues
+
+2. Resolved Issues
 ==================
 
-    Detector Server
-    ---------------
+    Detector Servers
+    ----------------
 
-    1.  (Eiger) Blocked Server
-        Very rarely, Eiger control or stop server would block and would require a restart
-        of server. This is due to both servers accessing the same link to get to FEB
-        registers. Locking has been implemented in server shared memory to resolve.
+    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.
 
 
-
-4. Known Issues
-===============
-
-    1.  (Eiger) Extra 8 byte Packets
-        When stopping detector acquisition while acquiring for more than 128 frames,
-        the next acquisition sends out first an 8 byte packet. This is discarded
-        by the slsReceiver/slsMultiReceiver. Please handle this in custom receivers.
+- better control of what is built (PR)?
+- cmake package has hardcoded path to zeromq library
 
 
-
-5. Firmware Requirements
+3. Firmware Requirements
 ========================
         
-        Eiger
-        =====  
-        Compatible version : 08.09.2020 (v27)
-        
-        Jungfrau
-        ========       
-        Compatible version : 24.07.2020 (v1.1, PCB v1.0) 
-                           : 21.07.2020 (v2.1, PCB v2.0)
-
-        Gotthard
-        ========   
-        Compatible version : 08.02.2018 (50um and 25um Master)
-                           : 09.02.2018 (25 um Slave) 
-
-        Mythen3
-        =======
-        Compatible version : 25.09.2020 (development)
-
-        Gotthard2
-        =========
-        Compatible version : 25.09.2020 (development)
-
-        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
-
+    Eiger
+    =====  
+    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
+    --------
+    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.
+
+
+
 6. Download, Documentation & Support
 ====================================
 

cmake/FindZeroMQ.cmake

@@ -1,112 +0,0 @@
-
-# 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,6 +25,12 @@ 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,8 +12,21 @@ include(CMakeFindDependencyMacro)
 
 set(SLS_USE_HDF5 "@SLS_USE_HDF5@")
 
-# Add optional dependencies here
+
+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
 if (SLS_USE_HDF5)
     find_dependency(HDF5)
 endif ()

conda-recepie/build.sh

@@ -8,13 +8,15 @@ 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\
      
-
-cmake --build . -- -j10
+NCORES=$(getconf _NPROCESSORS_ONLN)
+echo "Building using: ${NCORES} cores"
+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 $PREFIX/bin
-cp build/bin/slsDetectorGui $PREFIX/bin/.
+mkdir -p $PREFIX/bin
+cp build/install/bin/slsDetectorGui $PREFIX/bin/.

conda-recepie/copy_lib.sh

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

conda-recepie/copy_moench.sh

@@ -0,0 +1,4 @@
+#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,6 +59,16 @@ outputs:
     script: copy_lib.sh
 
     requirements:
+      build:
+        - {{ compiler('c') }}
+        - {{compiler('cxx')}}
+        - libstdcxx-ng
+        - libgcc-ng
+        - zeromq
+
+      host:
+        - zeromq
+
       run: 
         - libstdcxx-ng
         - libgcc-ng
@@ -78,6 +88,8 @@ outputs:
 
       host:
         - python
+        - {{ pin_subpackage('slsdetlib', exact=True) }}
+
 
       run:
         - libstdcxx-ng
@@ -94,8 +106,29 @@ 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/consuming.rst

@@ -9,7 +9,7 @@ CMake approaches.
 One can test with :ref:`detector simulators<Virtual Detector Servers>` before testing the API with a real detector or when a real detector is not at hand.
 
 CMake: slsDetectorPackage as submodule in your project
----------------------------------------
+---------------------------------------------------------------
 
 If you are using CMake to build your integration and want to build everything
 in one go, we support adding slsDetectorPackage as a subfolder in your cmake project. 

docs/src/firmware.rst

@@ -12,32 +12,7 @@ Download
 
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- bit files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
-
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - 
-         - 08.09.2020
-         - `v27 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/eiger/v27/>`__
-         - 
-       * - v4.0.0 - v4.2.0
-         - 
-         - 30.07.2019
-         - `v24 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/eiger/v24/>`__
-         - 
-       * - v3.1.0 - v3.1.5
-         - 
-         - 17.08.2017
-         - `v20 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/eiger/v20/>`__
-         -
-
+- `bit files <https://github.com/slsdetectorgroup/slsDetectorFirmware>`__
 
 Upgrade
 ^^^^^^^^
@@ -116,37 +91,7 @@ Download
 ^^^^^^^^^^^^^
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- pof files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
-
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - 2.0
-         - 21.07.2020
-         - `v2.1 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/jungfrau/v2_1/jungfrau_v2_1.pof>`__
-         - 
-       * - v5.0.0-rcx
-         - 1.0
-         - 24.07.2020
-         - `v1.1 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/jungfrau/v1_1/jungfrau_v1_1.pof>`__
-         - 
-       * - v4.0.1 - v4.2.0
-         - 1.0
-         - 06.12.2018
-         - `v0.7 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/jungfrau/v0_7/jungfrau_v0_7.pof>`__
-         - 
-       * - v3.1.0 - v3.1.5
-         - 1.0
-         - 13.11.2017
-         - `v0.6 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/jungfrau/v0_6/jungfrau_v0_6.pof>`__
-         -
-
+- `pof files <https://github.com/slsdetectorgroup/slsDetectorFirmware>`__
 
 
 Upgrade (from v4.x.x)
@@ -156,7 +101,7 @@ Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you
 
 #. Tftp must be installed on pc.
 
-#. Update client package to the latest (5.0.0-rc1).
+#. Update client package to the latest (5.x.x).
 
 #. Disable server respawning or kill old server
     .. code-block:: bash
@@ -204,11 +149,13 @@ Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you
         jungfrauDetectorServervxxx --stop-server 1953
 
 
-Upgrade (from v5.0.0-rcx)
+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
@@ -230,31 +177,8 @@ Download
 ^^^^^^^^^^^^^
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- pof files
-    .. list-table:: 
-       :widths: 15 15 15 15 5
-       :header-rows: 1
+- `pof files <https://github.com/slsdetectorgroup/slsDetectorFirmware>`__
 
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - All versions
-         - 50um
-         - 08.02.2018
-         - `50um <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/gotthard_I/50um/gotthard_I_50um.pof>`__
-         - 
-       * - All versions
-         - 25um (master)
-         - 08.02.2018
-         - `25um (master) <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/gotthard_I/25um/master/gotthard_I_25um_master.pof>`__
-         - 
-       * - All versions
-         - 25um (slave)
-         - 09.02.2018
-         - `25um (slave) <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/gotthard_I/25um/slave/gotthard_I_25um_slave.pof>`__
-         - 
 
 .. _firmware upgrade using blaster for blackfin:
 
@@ -294,26 +218,14 @@ Download
 
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- rbf files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
-
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - 
-         - 25.09.2020
-         - 
-         - development
+- rbf files (in developement)
 
 
-Upgrade (from v5.0.0-rcx)
+Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Always ensure that the client and server software are of the same release.
+
 #. Program from console
     .. code-block:: bash
 
@@ -337,25 +249,14 @@ Download
 ^^^^^^^^^^^^^
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- rbf files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
+- rbf files (in development)
 
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - 
-         - 25.09.2020
-         - 
-         - development
 
-Upgrade (from v5.0.0-rcx)
+Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Always ensure that the client and server software are of the same release.
+
 #. Program from console
     .. code-block:: bash
 
@@ -375,32 +276,16 @@ Download
 ^^^^^^^^^^^^^
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- pof files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
+- `pof files <https://github.com/slsdetectorgroup/slsDetectorFirmware>`__
 
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - EPCQ128
-         - 05.10.2020
-         - `v1.0 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/moench/EPCQ128/v1_0/moench_v1_0_201005.pof>`__
-         - 
-       * - v5.0.0-rcx
-         - EPCS128
-         - 05.10.2020
-         - `v1.0 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/moench/EPCS128/v1_0/moench_v1_0_201005.pof>`__
-         - 
 
-Upgrade (from v5.0.0-rcx)
+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
 
@@ -419,32 +304,16 @@ Download
 ^^^^^^^^^^^^^
 - detector server corresponding to package in slsDetectorPackage/serverBin
 
-- pof files
-    .. list-table:: 
-       :widths: 25 10 30 25 10
-       :header-rows: 1
+- `pof files <https://github.com/slsdetectorgroup/slsDetectorFirmware>`__
 
-       * - Software
-         - Hardware
-         - Firmware Date
-         - Firmware Link
-         - Comments
-       * - v5.0.0-rcx
-         - EPCQ128
-         - 05.10.2020
-         - `v1.0 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/ctb/EPCQ128/v1_0/ctb_v1_0_201005.pof>`__
-         - 
-       * - v5.0.0-rcx
-         - EPCS128
-         - 05.10.2020
-         - `v1.0 <https://github.com/slsdetectorgroup/slsDetectorFirmware/blob/master/binaries/ctb/EPCS128/v1_0/ctb_v1_0_201005.pof>`__
-         - 
 
-Upgrade (from v5.0.0-rcx)
+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
 
@@ -462,11 +331,12 @@ Check :ref:`firmware troubleshooting <blackfin firmware troubleshooting>` if you
 Firmware Troubleshooting with blackfin
 ----------------------------------------
 
-#. v4.x.x client after programming will most likely reboot the blackfin processor, regardless of error.
+1. v4.x.x client after programming will most likely reboot the blackfin processor, regardless of error.
 
-#. v5.x.x-rcx client after programming will not reboot the blackfin processor, if error occurred.
+2. v5.x.x-rcx client after programming will not reboot the blackfin processor, if error occurred.
+
+3. If a reboot occured with an incomplete firmware in flash, the blackfin will most likely not find the mtd3 drive. To see if this drive exists:
 
-#. If a reboot occured with an incomplete firmware in flash, the blackfin will most likely not find the mtd3 drive. To see if this drive exists:
   .. code-block:: bash
     
     # connect to the board
@@ -482,28 +352,45 @@ Firmware Troubleshooting with blackfin
 
 4. If one can see the mtd3 drive, one can already try to flash again using the **programfpga** command (without rebooting blackfin or detector). 
 
-#. If one can't list it, read the next section to try to get the blackfin to list it.
+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
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-This might take a few reruns (maybe even 10) until the mtd drive is accessed by the blackfin upon linux startup.
+How to get back mtd3 drive remotely (copying new kernel)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   .. code-block:: bash
     
-    # step 1: connect to the board
+    # step 1: get the kernel image (uImage.lzma) from slsdetectorgroup
+    # and copy it to pc's tftp folder
+
+    # step 2: connect to the board
     telnet bchipxxx
 
-    # step 2: check if mtd3 drive listed
-    more /proc/mtd
+    #step 3: go to directory for space
+    cd /var/tmp/
 
-    # step 3: tell fpga not to touch flash and reboot
-    echo 9 > /sys/class/gpio/export; 
-    echo out > /sys/class/gpio/gpio9/direction; 
-    echo 0 > /sys/class/gpio/gpio9/value;
+    # step 3: copy kernel to board
+    tftp pcxxx -r uImage.lzma -g
+
+    # step 4: verify kernel copied properly
+    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 4: repeat steps 1 - 3 until you see the mtd3 drive
-
+    
+    # step 9: verification
+    telnet bchipxxx
+    uname -a # verify kernel date
+    more /proc/mtd # verify mtd3 is listed
+    
 
 Last Resort using USB Blaster
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

docs/src/pyenums.rst

@@ -67,9 +67,6 @@ 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', 'masterFlags', 
+    'fileFormat', 'frameDiscardPolicy', 
     'readoutMode', 'runStatus', 'speedLevel', 'timingMode', 
     'timingSourceType']
 

docs/src/servers.rst

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

integrationTests/test-integrationDectector.cpp

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

libzmq-pkg-config/FindZeroMQ.cmake

@@ -0,0 +1,27 @@
+#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

@@ -0,0 +1,16 @@
+    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

@@ -1,19 +1,17 @@
 
-# find_package (Python COMPONENTS Interpreter Development)
-
 pybind11_add_module(_slsdet 
     src/main.cpp 
     src/enums.cpp
     src/detector.cpp
     src/network.cpp
+    src/pattern.cpp
+    src/scan.cpp
+    src/current.cpp
 )
 
 target_link_libraries(_slsdet PUBLIC 
-                        slsDetectorShared
-                        slsReceiverShared
-                        slsSupportShared
-                        ${ZeroMQ_LIBRARIES}
-                        )  
+                      slsDetectorStatic
+)  
 
 
 
@@ -33,6 +31,7 @@ set( PYTHON_FILES
     enums.py
     errors.py
     gotthard.py
+    pattern.py
     gotthard2.py
     moench.py
     proxy.py

python/examples/manipulate_pattern.py

@@ -0,0 +1,14 @@
+
+
+from slsdet import Detector, patternParameters
+
+d = Detector()
+pat = patternParameters()
+
+#Access to members of the structure using numpy arrays
+pat.patlimits = 0x0, 0xa
+
+d.setPattern(pat)
+
+#Load pattern from file
+pat.load("/some/dir/some.pat")

python/examples/use_currentsource.py

@@ -0,0 +1,11 @@
+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/use_enum.py

@@ -6,7 +6,7 @@ d = Detector()
 d.fformat = fileFormat.BINARY
 
 # Altough not recommended for convenience all enums 
-# and some other things can be impored using *
+# and some other things can be imported using *
 
 from slsdet import *
 d.speed = speedLevel.FULL_SPEED 
@@ -15,6 +15,6 @@ d.speed = speedLevel.FULL_SPEED
 
 import slsdet.enums
 for enum in dir(slsdet.enums):
-    # filter out special memebers
+    # filter out special members
     if not enum.startswith('_'):
         print(enum)

python/examples/using_scan.py

@@ -0,0 +1,21 @@
+
+from slsdet import Mythen3, scanParameters, dacIndex
+
+#Configure scan
+sp = scanParameters()
+sp.enable = 1 
+sp.dacInd = dacIndex.VTH1
+sp.startOffset = 0
+sp.stopOffset = 1000
+sp.stepSize = 100
+sp.dacSettleTime_ns = int(1e9)
+
+
+# Send scan to detector
+d = Mythen3()
+d.setScan(sp)
+
+#or d.scan = sp
+
+
+

python/scripts/basic.py

@@ -10,6 +10,8 @@ from slsdet.lookup import view, find
 import slsdet
 
 
+
+
 d = Detector()
 e = Eiger()
 c = Ctb()

python/scripts/compile_servers.py

@@ -0,0 +1,80 @@
+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,14 +11,30 @@ 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()
@@ -44,25 +60,80 @@ 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():
-        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
+        if key in allow_bitwise_op:
+            tag=", py::arithmetic()"
+        else:
+            tag=""
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}"{tag})\n')
+        operators = []
         for v in value:
-            data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
-        data.append('.export_values();\n\n')
+            if "operator" not in v:
+                data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\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)
 
-with open('../../slsSupportLib/include/sls_detector_defs.h') as f:
+
+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,15 +101,11 @@ def test_module_size(virtual_jf_detectors):
 
 def test_settings(virtual_jf_detectors):
     d = ExperimentalDetector()
-    assert d.settings == detectorSettings.DYNAMICGAIN
+    assert d.settings == detectorSettings.GAIN0
 
     gain_list = [
-        detectorSettings.FIXGAIN1,
-        detectorSettings.FIXGAIN2,
-        detectorSettings.FORCESWITCHG1,
-        detectorSettings.FORCESWITCHG2,
-        detectorSettings.DYNAMICHG0,
-        detectorSettings.DYNAMICGAIN,
+        detectorSettings.GAIN0,
+        detectorSettings.HIGHGAIN0,
     ]
 
     # Set all viable gain for Jungfrau to make sure nothing is crashing
@@ -117,15 +113,14 @@ def test_settings(virtual_jf_detectors):
         d.settings = gain
         assert d.settings == gain
 
-    d.setSettings(detectorSettings.FORCESWITCHG1, [1])
+    d.setSettings(detectorSettings.GAIN0, [1])
     assert d.settings == [
-        detectorSettings.DYNAMICGAIN,
-        detectorSettings.FORCESWITCHG1,
-        detectorSettings.DYNAMICGAIN,
+        detectorSettings.GAIN0,
+        detectorSettings.HIGHGAIN0,
     ]
 
-    d.settings = detectorSettings.DYNAMICGAIN
-    assert d.settings == detectorSettings.DYNAMICGAIN
+    d.settings = detectorSettings.GAIN0
+    assert d.settings == detectorSettings.GAIN0
 
 def test_frames(virtual_jf_detectors):
     d = ExperimentalDetector()
@@ -161,4 +156,34 @@ 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/setup.py

@@ -2,11 +2,12 @@
 Setup file for slsdet
 Build upon the pybind11 example found here: https://github.com/pybind/python_example
 """
-from setuptools import setup, Extension, find_packages
-from setuptools.command.build_ext import build_ext
-import sys
-import setuptools
+
 import os
+import sys
+sys.path.append('../libs/pybind11')
+from setuptools import setup, find_packages
+from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 __version__ = os.environ.get('GIT_DESCRIBE_TAG', 'developer')
 
@@ -19,109 +20,29 @@ def get_conda_path():
     return os.environ['CONDA_PREFIX']
 
 
-# class get_pybind_include(object):
-#     """Helper class to determine the pybind11 include path
-#     The purpose of this class is to postpone importing pybind11
-#     until it is actually installed, so that the ``get_include()``
-#     method can be invoked. """
-
-#     def __init__(self, user=False):
-#         self.user = user
-
-#     def __str__(self):
-#         import pybind11
-#         return pybind11.get_include(self.user)
-
-
+#TODO migrate to CMake build? 
 ext_modules = [
-    Extension(
+    Pybind11Extension(
         '_slsdet',
         ['src/main.cpp',
         'src/enums.cpp',
         'src/detector.cpp',
-        'src/network.cpp'],
+        'src/network.cpp',
+        'src/pattern.cpp',
+        'src/scan.cpp',],
         include_dirs=[
-            # Path to pybind11 headers
-            # get_pybind_include(),
-            # get_pybind_include(user=True),
             os.path.join('../libs/pybind11/include'),
             os.path.join(get_conda_path(), 'include'),
 
         ],
-        libraries=['SlsDetector', 'SlsReceiver', 'zmq'],
+        libraries=['SlsDetector', 'SlsSupport', 'SlsReceiver', 'zmq'],
         library_dirs=[
             os.path.join(get_conda_path(), 'lib'),
-            os.path.join(get_conda_path(), 'bin'),
         ],
-
         language='c++'
     ),
 ]
 
-
-# As of Python 3.6, CCompiler has a `has_flag` method.
-# cf http://bugs.python.org/issue26689
-def has_flag(compiler, flagname):
-    """Return a boolean indicating whether a flag name is supported on
-    the specified compiler.
-    """
-    import tempfile
-    with tempfile.NamedTemporaryFile('w', suffix='.cpp') as f:
-        f.write('int main (int argc, char **argv) { return 0; }')
-        try:
-            compiler.compile([f.name], extra_postargs=[flagname])
-        except setuptools.distutils.errors.CompileError:
-            return False
-    return True
-
-
-def cpp_flag(compiler):
-    """Return the -std=c++[11/14] compiler flag.
-    The c++14 is prefered over c++11 (when it is available).
-    """
-    if has_flag(compiler, '-std=c++14'):
-        return '-std=c++14'
-    elif has_flag(compiler, '-std=c++11'):
-        return '-std=c++11'
-    else:
-        raise RuntimeError('Unsupported compiler -- at least C++11 support '
-                           'is needed!')
-
-
-class BuildExt(build_ext):
-    """A custom build extension for adding compiler-specific options."""
-    c_opts = {
-        'msvc': ['/EHsc'],
-        'unix': [],
-    }
-
-    if sys.platform == 'darwin':
-        c_opts['unix'] += ['-stdlib=libc++', '-mmacosx-version-min=10.7']
-
-    def build_extensions(self):
-        ct = self.compiler.compiler_type
-        opts = self.c_opts.get(ct, [])
-        if ct == 'unix':
-            opts.append('-DVERSION_INFO="%s"' % self.distribution.get_version())
-            opts.append(cpp_flag(self.compiler))
-            if has_flag(self.compiler, '-fvisibility=hidden'):
-                opts.append('-fvisibility=hidden')
-        elif ct == 'msvc':
-            opts.append('/DVERSION_INFO=\\"%s\\"' % self.distribution.get_version())
-        for ext in self.extensions:
-            ext.extra_compile_args = opts
-
-        print('**************************************************')
-        print(ct)
-        print(opts)
-        print('**************************************************')
-        build_ext.build_extensions(self)
-        
-
-
-def get_shared_lib():
-    return [f for f in os.listdir('.') if '_slsdet' in f]
-
 setup(
     name='slsdet',
     version=__version__,
@@ -132,6 +53,6 @@ setup(
     long_description='',
     packages=find_packages(exclude=['contrib', 'docs', 'tests']),
     ext_modules=ext_modules,
-    cmdclass={'build_ext': BuildExt},
+    cmdclass={"build_ext": build_ext},
     zip_safe=False,
 )

python/slsdet/__init__.py

@@ -8,6 +8,8 @@ from .mythen3 import Mythen3
 from .gotthard2 import Gotthard2
 from .gotthard import Gotthard
 from .moench import Moench
+from .pattern import Pattern, patternParameters
+
 
 import _slsdet
 xy = _slsdet.xy
@@ -18,3 +20,5 @@ from .enums import *
 
 IpAddr = _slsdet.IpAddr
 MacAddr = _slsdet.MacAddr
+scanParameters = _slsdet.scanParameters
+currentSrcParameters = _slsdet.currentSrcParameters

python/slsdet/detector.py

@@ -7,6 +7,9 @@ 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
@@ -308,7 +311,7 @@ class Detector(CppDetectorApi):
         -----
         
         [Eiger] Use threshold command to load settings
-        [Jungfrau] DYNAMICGAIN, DYNAMICHG0, FIXGAIN1, FIXGAIN2, FORCESWITCHG1, FORCESWITCHG2 \n
+        [Jungfrau] GAIN0, HIGHGAIN0 \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
@@ -349,7 +352,7 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def nframes(self):
+    def framecounter(self):
         """
         [Jungfrau][Mythen3][Gotthard2][Moench][CTB] Number of frames from start run control.
         Note
@@ -359,6 +362,21 @@ 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):
@@ -367,7 +385,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. \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
         [Mythen3][Gotthard2] Default is 1. If module not connected or wrong module, powerchip will fail.
         """
         return self.getPowerChip()
@@ -1009,6 +1027,32 @@ class Detector(CppDetectorApi):
         ip = ut.make_ip(ip) #Convert from int or string to IpAddr
         ut.set_using_dict(self.setClientZmqIp, ip)
 
+
+    @property
+    def zmqhwm(self):
+        """
+        Client's zmq receive high water mark. Default is the zmq library's default (1000), can also be set here using -1. 
+        This is a high number and can be set to 2 for gui purposes. 
+        One must also set the receiver's send high water mark to similar value. Final effect is sum of them.
+	    Setting it via command line is useful only before zmq enabled (before opening gui).
+        """
+        return self.getClientZmqHwm()
+
+    @zmqhwm.setter
+    def zmqhwm(self, n_frames):
+        self.setClientZmqHwm(n_frames)
+
+    @property
+    def rx_zmqhwm(self):
+        """
+        Receiver's zmq send high water mark. Default is the zmq library's default (1000). This is a high number and can be set to 2 for gui purposes. One must also set the client's receive high water mark to similar value. Final effect is sum of them. Also restarts receiver zmq streaming if enabled. Can set to -1 to set default value.
+        """
+        return self.getRxZmqHwm()
+
+    @rx_zmqhwm.setter
+    def rx_zmqhwm(self, n_frames):
+        self.setRxZmqHwm(n_frames)
+
     @property
     @element
     def udp_dstip(self):
@@ -1499,7 +1543,7 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def timestamp(self):
+    def frametime(self):
         """[Jungfrau][Mythen3][Gotthard2][Moench][CTB] Timestamp at a frame start.
         Note
         ----
@@ -1601,20 +1645,22 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def speed(self):
+    def readoutspeed(self):
         """
-        [Eiger][Jungfrau] Readout speed of chip. Enum: speedLevel
+        [Eiger][Jungfrau|Gotthard2] Readout speed of chip. Enum: speedLevel
         Note
         -----
-        Options: FULL_SPEED, HALF_SPEED, QUARTER_SPEED \n
-        [Jungfrau] FULL_SPEED option only available from v2.0 boards and with setting number of interfaces to 2.  \n
+        [Jungfrau] FULL_SPEED, HALF_SPEED (Default), QUARTER_SPEED
+        [Eiger] FULL_SPEED (Default), HALF_SPEED, QUARTER_SPEED
+        [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.getSpeed())
+        return element_if_equal(self.getReadoutSpeed())
 
-    @speed.setter
-    def speed(self, value):
-        ut.set_using_dict(self.setSpeed, value)
+    @readoutspeed.setter
+    def readoutspeed(self, value):
+        ut.set_using_dict(self.setReadoutSpeed, value)
 
     @property
     def rx_jsonpara(self):
@@ -1670,6 +1716,8 @@ class Detector(CppDetectorApi):
         To change settings as well or set threshold without trimbits, use setThresholdEnergy.
         :setter: It loads trim files from settingspath.
         """
+        if self.type == detectorType.MYTHEN3:
+            return self.getAllThresholdEnergy()
         return self.getThresholdEnergy()
 
     @threshold.setter
@@ -1721,7 +1769,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.
+        [Mythen3] Sets vth1, vth2 and vth3 to the same value for enabled counters.
         """
         return self.getDAC(dacIndex.VTHRESHOLD)
 
@@ -1759,10 +1807,25 @@ class Detector(CppDetectorApi):
 
     """
 
-    <<<-----------------------Eiger specific----------------------->>>
+    <<<Eiger>>>
 
     """
 
+    @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):
@@ -1800,19 +1863,21 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def readnlines(self):
+    def readnrows(self):
         """
-        [Eiger] Number of lines to read out per half module 
+        [Eiger] Number of rows to read out per half module starting from the centre.
+        [Jungfrau] Number of rows to read per module starting from the centre.
         Note
         ----
-        Options: 0 - 256. 256 is default. \n
-        The permissible values depend on dynamic range and 10Gbe enabled.
+        [Eiger] Options: 1 - 256. 256 is default. \n
+        [Eiger]The permissible values depend on dynamic range and 10Gbe enabled.\n\n
+        [Jungfrau] Options: 8 - 512 (multiples of 8)
         """
-        return self.getPartialReadout()
+        return self.getReadNRows()
 
-    @readnlines.setter
-    def readnlines(self, value):
-        ut.set_using_dict(self.setPartialReadout, value)
+    @readnrows.setter
+    def readnrows(self, value):
+        ut.set_using_dict(self.setReadNRows, value)
 
 
     @property
@@ -1943,9 +2008,23 @@ 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):
@@ -1953,19 +2032,44 @@ 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).\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). The % is only for chipv1.0, the duration can be set for chipv1.1.\n
         Default is 0 or this mode disabled (comparator enabled throughout). 1 enables mode. 0 disables mode. 
         """
-        return self.getAutoCompDisable()
+        return self.getAutoComparatorDisable()
 
     @auto_comp_disable.setter
     def auto_comp_disable(self, value):
-        ut.set_using_dict(self.setAutoCompDisable, value)
+        ut.set_using_dict(self.setAutoComparatorDisable, 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
     @element
-    def now(self):
+    def runtime(self):
         """[Jungfrau][Mythen3][Gotthard2][Moench][CTB] Time from detector start up.
         Note
         -----
@@ -1980,7 +2084,7 @@ class Detector(CppDetectorApi):
         [Jungfrau] Number of additional storage cells. 
         Note
         ----
-        For advanced users only. \n
+        Only for chip v1.0. For advanced users only. \n
         Options: 0 - 15. Default is 0.
         The #images = #frames x #triggers x (#storagecells + 1)
         """
@@ -1999,7 +2103,7 @@ class Detector(CppDetectorApi):
         Note
         ----
         For advanced users only.
-        Options 0-15. Default is 15. \n
+        Options 0-max. max is 15 (default) for chipv1.0 and 3 (default) for chipv1.1. \n
         """
         return self.getStorageCellStart()
 
@@ -2013,7 +2117,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
         -----
-        For advanced users only \n
+        Only applicable for chipv1.0. 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
 
@@ -2105,6 +2209,40 @@ 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>>>---------------------------
     """
@@ -2133,18 +2271,37 @@ class Detector(CppDetectorApi):
 
     @property
     @element
-    def filter(self):
-        """[Gotthard2] Set filter resistor. 
+    def filterresistor(self):
+        """
+        [Gotthard2][Jungfrau] Set filter resistor. Increasing values for increasing "
+        "resistance.
         Note
         ----
-        Default is 0. Options: 0-3.
+        Advanced user command.
+        [Gotthard2] Default is 0. Options: 0-3.
+        [Jungfrau] Default is 1. Options: 0-1.
         """
-        return self.getFilter()
+        return self.getFilterResistor()
 
-    @filter.setter
-    def filter(self, value):
-        ut.set_using_dict(self.setFilter, value)
+    @filterresistor.setter
+    def filterresistor(self, value):
+        ut.set_using_dict(self.setFilterResistor, 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):
         """
@@ -2184,7 +2341,7 @@ class Detector(CppDetectorApi):
     @element
     def veto(self):
         """
-        [Gotthard2] Enable or disable veto data streaming from detector. 
+        [Gotthard2] Enable or disable veto data from chip. 
         Note
         ----
         Default is 0.
@@ -2304,6 +2461,49 @@ 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
     """
@@ -2353,6 +2553,7 @@ 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
         -----------
@@ -2493,7 +2694,12 @@ class Detector(CppDetectorApi):
     @property
     @element
     def dbitpipeline(self):
-        """[Ctb] Pipeline of the clock for latching digital bits. """
+        """[Ctb][Gotthard2] Pipeline of the clock for latching digital bits. 
+        Note
+        ----
+        [CTB] Options: 0 - 255
+        [Gotthard2] Options: 0 - 7
+        """
         return self.getDBITPipeline()
 
     @dbitpipeline.setter
@@ -3079,6 +3285,14 @@ class Detector(CppDetectorApi):
         """
         return ClkFreqProxy(self)
 
+
+    def readout(self):
+        """
+        Mythen3] Starts detector readout. Status changes to TRANSMITTING and automatically returns to idle at the end of readout.
+        """
+        self.startDetectorReadout()
+    
+
     """
     ---------------------------<<<Debug>>>---------------------------
     """

python/slsdet/enums.py

@@ -1,17 +1,20 @@
+"""
+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
-runStatus = _slsdet.slsDetectorDefs.runStatus
-speedLevel = _slsdet.slsDetectorDefs.speedLevel
-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
+for name, cls in _slsdet.slsDetectorDefs.__dict__.items():
+    if isinstance(cls, type):
+        exec(f'{name} = {cls.__module__}.{cls.__qualname__}')
+

python/slsdet/pattern.py

@@ -0,0 +1,53 @@
+import _slsdet
+
+from _slsdet import Pattern
+
+
+class patternParameters(_slsdet.patternParameters):
+    def __init__(self):
+        super().__init__()
+        self.view = self.numpy_view()
+        self.names = self.view.dtype.names
+
+    def __getattr__(self, name):
+        if name in self.names:
+            return self.view[name][0]
+        else:
+            raise KeyError(f"Key: {name} not found")
+
+    def __setattr__(self, name, value):
+        if name in ["view", "names"]:
+            self.__dict__[name] = value
+        elif name in self.names:
+            self.view[name] = value
+        else:
+            raise KeyError(f"Key: {name} not found")
+
+    # Provide custom dir for tab completion
+    def __dir__(self):
+        return self.names
+
+
+class Pattern(_slsdet.Pattern):
+    def __init__(self):
+        super().__init__()
+        self.view = self.data().numpy_view()
+        self.names = self.view.dtype.names
+
+    def __getattr__(self, name):
+        if name in self.names:
+            return self.view[name][0]
+        else:
+            raise KeyError(f"Key: {name} not found")
+
+    def __setattr__(self, name, value):
+        if name in ["view", "names"]:
+            self.__dict__[name] = value
+        elif name in self.names:
+            self.view[name] = value
+        else:
+            raise KeyError(f"Key: {name} not found")
+
+    # Provide custom dir for tab completion
+    def __dir__(self):
+        return self.names

python/slsdet/utils.py

@@ -41,7 +41,7 @@ def list_to_bitmask(values):
     return mask
 
 def make_bitmask(args):
-    if isinstance(args, list):
+    if isinstance(args, (list,tuple)):
         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

@@ -0,0 +1,26 @@
+#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,6 +69,10 @@ 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,
@@ -102,6 +106,34 @@ void init_det(py::module &m) {
              (void (Detector::*)(defs::detectorSettings, sls::Positions)) &
                  Detector::setSettings,
              py::arg(), py::arg() = Positions{})
+        .def("getThresholdEnergy",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getThresholdEnergy,
+             py::arg() = Positions{})
+        .def("getAllThresholdEnergy",
+             (Result<std::array<int, 3>>(Detector::*)(sls::Positions) const) &
+                 Detector::getAllThresholdEnergy,
+             py::arg() = Positions{})
+        .def("setThresholdEnergy",
+             (void (Detector::*)(int, defs::detectorSettings, bool,
+                                 sls::Positions)) &
+                 Detector::setThresholdEnergy,
+             py::arg(), py::arg() = defs::STANDARD, py::arg() = true,
+             py::arg() = Positions{})
+        .def("setThresholdEnergy",
+             (void (Detector::*)(std::array<int, 3>, defs::detectorSettings,
+                                 bool, sls::Positions)) &
+                 Detector::setThresholdEnergy,
+             py::arg(), py::arg() = defs::STANDARD, py::arg() = true,
+             py::arg() = Positions{})
+        .def("getSettingsPath",
+             (Result<std::string>(Detector::*)(sls::Positions) const) &
+                 Detector::getSettingsPath,
+             py::arg() = Positions{})
+        .def("setSettingsPath",
+             (void (Detector::*)(const std::string &, sls::Positions)) &
+                 Detector::setSettingsPath,
+             py::arg(), py::arg() = Positions{})
         .def("loadTrimbits",
              (void (Detector::*)(const std::string &, sls::Positions)) &
                  Detector::loadTrimbits,
@@ -114,12 +146,31 @@ void init_det(py::module &m) {
              (void (Detector::*)(int, sls::Positions)) &
                  Detector::setAllTrimbits,
              py::arg(), py::arg() = Positions{})
+        .def("getTrimEnergies",
+             (Result<std::vector<int>>(Detector::*)(sls::Positions) const) &
+                 Detector::getTrimEnergies,
+             py::arg() = Positions{})
+        .def("setTrimEnergies",
+             (void (Detector::*)(std::vector<int>, sls::Positions)) &
+                 Detector::setTrimEnergies,
+             py::arg(), py::arg() = Positions{})
         .def("getGapPixelsinCallback",
              (bool (Detector::*)() const) & Detector::getGapPixelsinCallback)
         .def("setGapPixelsinCallback",
              (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,
+             py::arg() = Positions{})
         .def("registerAcquisitionFinishedCallback",
              (void (Detector::*)(void (*)(double, int, void *), void *)) &
                  Detector::registerAcquisitionFinishedCallback,
@@ -203,14 +254,17 @@ void init_det(py::module &m) {
         .def("getTimingModeList",
              (std::vector<defs::timingMode>(Detector::*)() const) &
                  Detector::getTimingModeList)
-        .def("getSpeed",
+        .def("getReadoutSpeed",
              (Result<defs::speedLevel>(Detector::*)(sls::Positions) const) &
-                 Detector::getSpeed,
+                 Detector::getReadoutSpeed,
              py::arg() = Positions{})
-        .def("setSpeed",
+        .def("setReadoutSpeed",
              (void (Detector::*)(defs::speedLevel, sls::Positions)) &
-                 Detector::setSpeed,
+                 Detector::setReadoutSpeed,
              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,
@@ -314,6 +368,28 @@ void init_det(py::module &m) {
              py::arg(), py::arg() = Positions{})
         .def("getDacList", (std::vector<defs::dacIndex>(Detector::*)() const) &
                                Detector::getDacList)
+        .def("getDefaultDac",
+             (Result<int>(Detector::*)(defs::dacIndex, sls::Positions)) &
+                 Detector::getDefaultDac,
+             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) &
@@ -350,13 +426,50 @@ 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)
         .def("startReceiver", (void (Detector::*)()) & Detector::startReceiver)
         .def("stopReceiver", (void (Detector::*)()) & Detector::stopReceiver)
         .def("startDetector", (void (Detector::*)()) & Detector::startDetector)
-        .def("stopDetector", (void (Detector::*)()) & Detector::stopDetector)
+        .def("startDetectorReadout",
+             (void (Detector::*)()) & Detector::startDetectorReadout)
+        .def("stopDetector",
+             (void (Detector::*)(sls::Positions)) & Detector::stopDetector,
+             py::arg() = Positions{})
         .def("getDetectorStatus",
              (Result<defs::runStatus>(Detector::*)(sls::Positions) const) &
                  Detector::getDetectorStatus,
@@ -383,9 +496,9 @@ void init_det(py::module &m) {
                  Detector::setNextFrameNumber,
              py::arg(), py::arg() = Positions{})
         .def("sendSoftwareTrigger",
-             (void (Detector::*)(sls::Positions)) &
+             (void (Detector::*)(const bool, sls::Positions)) &
                  Detector::sendSoftwareTrigger,
-             py::arg() = Positions{})
+             py::arg() = false, py::arg() = Positions{})
         .def("getScan",
              (Result<defs::scanParameters>(Detector::*)(sls::Positions) const) &
                  Detector::getScan,
@@ -446,6 +559,31 @@ 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,
@@ -599,15 +737,15 @@ void init_det(py::module &m) {
                  Detector::setPartialFramesPadding,
              py::arg(), py::arg() = Positions{})
         .def("getRxUDPSocketBufferSize",
-             (Result<int64_t>(Detector::*)(sls::Positions) const) &
+             (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getRxUDPSocketBufferSize,
              py::arg() = Positions{})
         .def("setRxUDPSocketBufferSize",
-             (void (Detector::*)(int64_t, sls::Positions)) &
+             (void (Detector::*)(int, sls::Positions)) &
                  Detector::setRxUDPSocketBufferSize,
              py::arg(), py::arg() = Positions{})
         .def("getRxRealUDPSocketBufferSize",
-             (Result<int64_t>(Detector::*)(sls::Positions) const) &
+             (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getRxRealUDPSocketBufferSize,
              py::arg() = Positions{})
         .def("getRxLock",
@@ -747,6 +885,17 @@ void init_det(py::module &m) {
              (void (Detector::*)(const sls::IpAddr, sls::Positions)) &
                  Detector::setClientZmqIp,
              py::arg(), py::arg() = Positions{})
+        .def("getClientZmqHwm",
+             (int (Detector::*)() const) & Detector::getClientZmqHwm)
+        .def("setClientZmqHwm",
+             (void (Detector::*)(const int)) & Detector::setClientZmqHwm,
+             py::arg())
+        .def("getRxZmqHwm",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getRxZmqHwm,
+             py::arg() = Positions{})
+        .def("setRxZmqHwm",
+             (void (Detector::*)(const int)) & Detector::setRxZmqHwm, py::arg())
         .def("getSubExptime",
              (Result<sls::ns>(Detector::*)(sls::Positions) const) &
                  Detector::getSubExptime,
@@ -763,24 +912,6 @@ void init_det(py::module &m) {
              (void (Detector::*)(sls::ns, sls::Positions)) &
                  Detector::setSubDeadTime,
              py::arg(), py::arg() = Positions{})
-        .def("getThresholdEnergy",
-             (Result<int>(Detector::*)(sls::Positions) const) &
-                 Detector::getThresholdEnergy,
-             py::arg() = Positions{})
-        .def("setThresholdEnergy",
-             (void (Detector::*)(int, defs::detectorSettings, bool,
-                                 sls::Positions)) &
-                 Detector::setThresholdEnergy,
-             py::arg(), py::arg() = defs::STANDARD, py::arg() = true,
-             py::arg() = Positions{})
-        .def("getSettingsPath",
-             (Result<std::string>(Detector::*)(sls::Positions) const) &
-                 Detector::getSettingsPath,
-             py::arg() = Positions{})
-        .def("setSettingsPath",
-             (void (Detector::*)(const std::string &, sls::Positions)) &
-                 Detector::setSettingsPath,
-             py::arg(), py::arg() = Positions{})
         .def("getOverFlowMode",
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::getOverFlowMode,
@@ -789,21 +920,6 @@ 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("getTrimEnergies",
-             (Result<std::vector<int>>(Detector::*)(sls::Positions) const) &
-                 Detector::getTrimEnergies,
-             py::arg() = Positions{})
-        .def("setTrimEnergies",
-             (void (Detector::*)(std::vector<int>, sls::Positions)) &
-                 Detector::setTrimEnergies,
-             py::arg(), py::arg() = Positions{})
         .def("getRateCorrection",
              (Result<sls::ns>(Detector::*)(sls::Positions) const) &
                  Detector::getRateCorrection,
@@ -816,14 +932,6 @@ 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,
@@ -848,14 +956,6 @@ 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,
@@ -881,6 +981,20 @@ 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,
@@ -905,13 +1019,21 @@ void init_det(py::module &m) {
              (void (Detector::*)(sls::Positions)) &
                  Detector::resetTemperatureEvent,
              py::arg() = Positions{})
-        .def("getAutoCompDisable",
+        .def("getAutoComparatorDisable",
              (Result<bool>(Detector::*)(sls::Positions) const) &
-                 Detector::getAutoCompDisable,
+                 Detector::getAutoComparatorDisable,
              py::arg() = Positions{})
-        .def("setAutoCompDisable",
+        .def("setAutoComparatorDisable",
              (void (Detector::*)(bool, sls::Positions)) &
-                 Detector::setAutoCompDisable,
+                 Detector::setAutoComparatorDisable,
+             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) &
@@ -937,6 +1059,25 @@ 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,
@@ -1012,21 +1153,6 @@ 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) &
@@ -1044,6 +1170,27 @@ 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) &
@@ -1102,6 +1249,20 @@ void init_det(py::module &m) {
              (Result<std::array<ns, 3>>(Detector::*)(sls::Positions) const) &
                  Detector::getGateDelayForAllGates,
              py::arg() = Positions{})
+        .def("getMaster",
+             (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,
@@ -1183,14 +1344,6 @@ 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,
@@ -1251,9 +1404,17 @@ void init_det(py::module &m) {
              (void (Detector::*)(const std::string &, sls::Positions)) &
                  Detector::setPattern,
              py::arg(), py::arg() = Positions{})
+        .def("setPattern",
+             (void (Detector::*)(const sls::Pattern &, sls::Positions)) &
+                 Detector::setPattern,
+             py::arg(), py::arg() = Positions{})
         .def("savePattern",
              (void (Detector::*)(const std::string &)) & Detector::savePattern,
              py::arg())
+        .def("loadDefaultPattern",
+             (void (Detector::*)(sls::Positions)) &
+                 Detector::loadDefaultPattern,
+             py::arg() = Positions{})
         .def("getPatternIOControl",
              (Result<uint64_t>(Detector::*)(sls::Positions) const) &
                  Detector::getPatternIOControl,

python/src/enums.cpp

@@ -2,10 +2,12 @@
  * warning */
 
 #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/sls_detector_defs.h"
 namespace py = pybind11;
 void init_enums(py::module &m) {
@@ -208,13 +210,9 @@ void init_enums(py::module &m) {
         .value("LOWGAIN", slsDetectorDefs::detectorSettings::LOWGAIN)
         .value("MEDIUMGAIN", slsDetectorDefs::detectorSettings::MEDIUMGAIN)
         .value("VERYHIGHGAIN", slsDetectorDefs::detectorSettings::VERYHIGHGAIN)
-        .value("DYNAMICHG0", slsDetectorDefs::detectorSettings::DYNAMICHG0)
+        .value("HIGHGAIN0", slsDetectorDefs::detectorSettings::HIGHGAIN0)
         .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)
@@ -228,6 +226,7 @@ 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)
@@ -251,12 +250,8 @@ 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)
-        .export_values();
-
-    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)
+        .value("G2_108MHZ", slsDetectorDefs::speedLevel::G2_108MHZ)
+        .value("G2_144MHZ", slsDetectorDefs::speedLevel::G2_144MHZ)
         .export_values();
 
     py::enum_<slsDetectorDefs::burstMode>(Defs, "burstMode")
@@ -275,4 +270,52 @@ 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/enums_in.cpp

@@ -1,18 +1,19 @@
 #include <pybind11/chrono.h>
+#include <pybind11/numpy.h>
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
 #include "sls/sls_detector_defs.h"
+#include "sls/Pattern.h"
 namespace py = pybind11;
 void init_enums(py::module &m) {
     py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
     py::class_<slsDetectorDefs::xy> xy(m, "xy");
     xy.def(py::init());
-	xy.def(py::init<int,int>());
+    xy.def(py::init<int, int>());
     xy.def_readwrite("x", &slsDetectorDefs::xy::x);
     xy.def_readwrite("y", &slsDetectorDefs::xy::y);
 
-[[ENUMS]]
-
+    [[ENUMS]]
 }

python/src/main.cpp

@@ -19,6 +19,9 @@ void init_enums(py::module &);
 void init_experimental(py::module &);
 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
@@ -33,6 +36,9 @@ PYBIND11_MODULE(_slsdet, m) {
      init_enums(m);
      init_det(m);
      init_network(m);
+     init_pattern(m);
+     init_scan(m);
+     init_source(m);
     //  init_experimental(m);
     
 

python/src/pattern.cpp

@@ -0,0 +1,29 @@
+#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/sls_detector_defs.h"
+namespace py = pybind11;
+void init_pattern(py::module &m) {
+
+    using pat = sls::patternParameters;
+    py::class_<pat> patternParameters(m, "patternParameters");
+
+    PYBIND11_NUMPY_DTYPE(pat, word, ioctrl, limits, loop, nloop, wait,
+                         waittime);
+
+    patternParameters.def(py::init());
+    patternParameters.def("numpy_view", [](py::object &obj) {
+        pat &o = obj.cast<pat &>();
+        return py::array_t<pat>(1, &o, obj);
+    });
+
+    py::class_<sls::Pattern> Pattern(m, "Pattern");
+    Pattern.def(py::init());
+    Pattern.def("load", &sls::Pattern::load);
+    Pattern.def("data", (pat * (sls::Pattern::*)()) & sls::Pattern::data,
+                py::return_value_policy::reference);
+}

python/src/scan.cpp

@@ -0,0 +1,39 @@
+#include <pybind11/chrono.h>
+#include <pybind11/numpy.h>
+#include <pybind11/operators.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <sstream>
+#include "sls/sls_detector_defs.h"
+namespace py = pybind11;
+void init_scan(py::module &m) {
+
+    using sp = slsDetectorDefs::scanParameters;
+    py::class_<sp> scanParameters(m, "scanParameters");
+
+    scanParameters.def(py::init());
+
+    scanParameters.def(py::init<slsDetectorDefs::dacIndex, int, int, int>());
+    scanParameters.def(py::init<slsDetectorDefs::dacIndex, int, int, int, std::chrono::nanoseconds>());
+    scanParameters.def_readwrite("enable", &sp::enable);
+    scanParameters.def_readwrite("dacInd", &sp::dacInd);
+    scanParameters.def_readwrite("startOffset", &sp::startOffset);
+    scanParameters.def_readwrite("stopOffset", &sp::stopOffset);
+    scanParameters.def_readwrite("stepSize", &sp::stepSize);
+    scanParameters.def_readwrite("dacSettleTime_ns", &sp::dacSettleTime_ns);
+    scanParameters.def("__repr__", [](const sp &a){
+        std::ostringstream oss;
+        auto indent = "  ";
+        oss << "<scanParameters>\n";
+        oss << indent << "enable: " <<  a.enable << '\n';
+        oss << indent << "dacInd: " <<  a.dacInd << '\n';
+        oss << indent << "startOffset: " <<  a.startOffset << '\n';
+        oss << indent << "stopOffset: " <<  a.stopOffset << '\n';
+        oss << indent << "stepSize: " <<  a.stepSize << '\n';
+        oss << indent << "dacSettleTime_ns: " <<  a.dacSettleTime_ns;
+        return oss.str();
+    });
+
+
+
+}

serverBin/ctbDetectorServerv5.0.0

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

serverBin/ctbDetectorServerv6.0.0-rc1

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

serverBin/eigerDetectorServerv5.0.0

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

serverBin/eigerDetectorServerv6.0.0-rc1

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

serverBin/gotthard2DetectorServerv5.0.0

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

serverBin/gotthard2DetectorServerv6.0.0-rc1

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

serverBin/gotthardDetectorServerv5.0.0

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

serverBin/gotthardDetectorServerv6.0.0-rc1

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

serverBin/jungfrauDetectorServerv5.0.0

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

serverBin/jungfrauDetectorServerv6.0.0-rc1

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

serverBin/moenchDetectorServerv5.0.0

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

serverBin/moenchDetectorServerv6.0.0-rc1

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

serverBin/mythen3DetectorServerv5.0.0

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

serverBin/mythen3DetectorServerv6.0.0-rc1

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

settingsdir/mythen/fast/calibration.snxxx

@@ -1 +0,0 @@
-800 10

settingsdir/mythen/fast/fast.cal

@@ -1 +0,0 @@
-829 9.3

settingsdir/mythen/highgain/calibration.snxxx

@@ -1 +0,0 @@
-800 10

settingsdir/mythen/highgain/highgain.cal

@@ -1 +0,0 @@
-804 15.0

settingsdir/mythen/standard/calibration.snxxx

@@ -1 +0,0 @@
-800 10

settingsdir/mythen/standard/standard.cal

@@ -1 +0,0 @@
-817 11.6

slsDetectorCalibration/circularFifo.h

@@ -0,0 +1,156 @@
+#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

@@ -0,0 +1,238 @@
+#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,6 +14,8 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
   const int nSamples;
   const int offset;
 
+
+
   double ghost[200][25];
   double xtalk;
 
@@ -29,17 +31,22 @@ 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=0): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), 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) {
+    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;
@@ -50,11 +57,11 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
     int i;
     int adc4(0);
   
-    for (int ip=0; ip<npackets; ip++) {
-      for (int is=0; is<128; is++) {
-
+    //for (int ip=0; ip<npackets; ip++) {
+    // 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++) {
@@ -70,7 +77,7 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 	  }
 	}
       }
-    }
+  // }
 
     
     int ii=0;

slsDetectorCalibration/energyCalibration.cpp

@@ -0,0 +1,798 @@
+#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,6 +98,8 @@ 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
@@ -153,6 +155,8 @@ 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
@@ -285,7 +289,9 @@ 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 
@@ -315,16 +321,8 @@ 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);
-
-
-  /**
-     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);
+  TF1 *fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar);
+  TF1 *fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar);
 
 
   /**
@@ -399,6 +397,8 @@ class energyCalibration  {
 */
   
   void initFitFunction(TF1 *fun, TH1 *h1);
+  void initFitFunctionKb(TF1 *fun, TH1 *h1);
+  void initFitFunctionKaDoublet(TF1 *fun, TH1 *h1);
 
 
   /**
@@ -410,6 +410,8 @@ 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
 
@@ -423,11 +425,16 @@ 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 */
 

slsDetectorCalibration/interpolations/slsInterpolation.h

@@ -447,19 +447,6 @@ class slsInterpolation
       etax=(-l+r)/sum;
       etay=(-b+t)/sum;
     }
-    /* if (etax<-1 || etax>1 || etay<-1 || etay>1) { */
-    /*   cout << "**********" << etax << " " << etay << endl; */
-    /*    for (int ix=0; ix<3; ix++) { */
-    /*   for (int iy=0; iy<3; iy++) { */
-    /* 	cout << cl[iy+3*ix] << "\t" ; */
-
-    /*   } */
-    /*   cout << endl; */
-    /* } */
-    /*    cout << sum << " " << l << " " << r << " " << t << " " << b << endl; */
-
-    /* } */
-
 
     if (etax>=0 && etay>=0)
       return TOP_RIGHT;
@@ -479,6 +466,29 @@ class slsInterpolation
   }
 
 
+
+  static int calcEta3X(double *cl, double &etax, double &etay, double &sum) {
+    double l,r,t,b;
+    sum=cl[0]+cl[1]+cl[2]+cl[3]+cl[4]+cl[5]+cl[6]+cl[7]+cl[8];
+    if (sum>0) {
+      l=cl[3];
+      r=cl[5];
+      b=cl[1];
+      t=cl[7];
+      etax=(-l+r)/sum;
+      etay=(-b+t)/sum;
+    }
+    return -1;
+  }
+
+  static int calcEta3X(int *cl, double &etax, double &etay, double &sum) {
+    double cli[9];
+    for (int ix=0; ix<9; ix++) cli[ix]=cl[ix];
+    
+    return calcEta3X(cli, etax, etay, sum);
+  }
+
+
   /* static int calcMyEta(double totquad, int quad, double *cl, double &etax, double &etay) { */
   /*   double l,r,t,b, sum; */
   /*   int yoff; */
@@ -537,21 +547,6 @@ class slsInterpolation
 
 
 
-  /* static int calcEta3X(double *cl, double &etax, double &etay, double &sum) { */
-  /*   double l,r,t,b; */
-  /*   sum=cl[0]+cl[1]+cl[2]+cl[3]+cl[4]+cl[5]+cl[6]+cl[7]+cl[8]; */
-  /*   if (sum>0) { */
-  /*     l=cl[3]; */
-  /*     r=cl[5]; */
-  /*     b=cl[1]; */
-  /*     t=cl[7]; */
-  /*     etax=(-l+r)/sum; */
-  /*     etay=(-b+t)/sum; */
-  /*   } */
-  /*   return -1; */
-  /* } */
-
-
   /* static int calcEta3X(int *cl, double &etax, double &etay, double &sum) { */
   /*   double l,r,t,b; */
   /*   sum=cl[0]+cl[1]+cl[2]+cl[3]+cl[4]+cl[5]+cl[6]+cl[7]+cl[8]; */

slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder

@@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ 
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=jungfrauClusterFinder.cpp
+
+
+all: jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+
+
+jungfrauClusterFinder:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinder  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  
+
+
+jungfrauClusterFinderHighZ:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinderHighZ  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DHIGHZ 
+
+
+
+
+jungfrauMakeEta:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauMakeEta jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+jungfrauInterpolation:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauInterpolation jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+jungfrauNoInterpolation:  jungfrauNoInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauNoInterpolation jungfrauNoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+jungfrauPhotonCounter: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounter  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+jungfrauAnalog: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalog  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+jungfrauPhotonCounterHighZ: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounterHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+jungfrauAnalogHighZ: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalogHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+

slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder~

@@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=moench03ClusterFinder.cpp
+
+
+all: moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+
+
+moenchClusterFinder:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinder  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER 
+
+
+moenchClusterFinderHighZ:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinderHighZ  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER -DHIGHZ 
+
+
+
+
+moenchMakeEta:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchMakeEta moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+moenchInterpolation:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchInterpolation moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+moenchNoInterpolation:  moench03NoInterpolation.cpp  $(INCS) clean
+			 g++ -o moenchNoInterpolation moench03NoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+moenchPhotonCounter: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounter  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+moenchAnalog: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalog  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+moenchPhotonCounterHighZ: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounterHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+moenchAnalogHighZ: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalogHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+

slsDetectorCalibration/jungfrauExecutables/Makefile.zmq

@@ -0,0 +1,23 @@
+
+INCDIR=   -I. -I../dataStructures ../tiffIO.cpp -I../ -I../interpolations/ -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ -I../../libs/rapidjson/
+LDFLAG= -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt -ltiff   -O3  -std=c++11 -Wall -L../../build/bin/ -lSlsSupport
+#-L../../bin -lhdf5  -L.
+
+#DESTDIR?=../bin
+
+all:  moenchZmqProcess moenchZmq04Process
+ #moenchZmqProcessCtbGui
+
+moenchZmqProcess:  moenchZmqProcess.cpp   clean
+		      g++ -o moenchZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP 
+
+moenchZmq04Process:  moenchZmqProcess.cpp   clean
+		      g++ -o moench04ZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DMOENCH04 
+
+#moenchZmqProcessCtbGui:  moenchZmqProcess.cpp   clean
+#		      g++ -o moenchZmqProcessCtbGui  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DCTBGUI
+
+clean: 	
+	rm -f  moenchZmqProcess  
+
+

slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp

@@ -0,0 +1,161 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#include "jungfrauHighZSingleChipData.h"
+
+
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+  jungfrauHighZSingleChipData *decoder=new  jungfrauHighZSingleChipData();
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+
+  int* image;
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+
+  	mt->pushData(buff);
+  	mt->nextThread();
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp~

@@ -0,0 +1,237 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+#ifdef REORDERED
+#include "moench03T1ReorderedData.h"
+#endif
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+#ifdef REORDERED
+  moench03T1ReorderedData *decoder=new  moench03T1ReorderedData();
+  cout << "REORDERED DATA!"<<endl;
+#endif
+
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+  // filter->readPedestals("/scratch/ped_100.tiff");
+  // interp->readFlatField("/scratch/eta_100.tiff",etamin,etamax);
+  // cout << "filter "<< endl;
+  
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  //  strcpy(pedfname,argv[6]);
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+ 
+
+
+
+
+
+
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	// for (int ix=0; ix<400; ix++)
+	//   for (int iy=0; iy<400; iy++) {
+	//     if (decoder->getChannel(buff, ix, iy)<3000 || decoder->getChannel(buff, ix, iy)>8000) {
+	//       cout <<  ifr << " " << ff << " " << ix << " " << iy << " " << decoder->getChannel(buff, ix, iy) << endl ;
+	//     }
+	//   }
+
+  	mt->pushData(buff);
+  // 	//         //pop
+  	mt->nextThread();
+  // // 		//	cout << " " << (void*)buff;
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauInterpolation.cpp

@@ -0,0 +1,250 @@
+
+#include "sls/ansi.h"
+#include <iostream>
+
+//#include "moench03T1ZmqData.h"
+//#define DOUBLE_SPH
+//#define MANYFILES
+
+#ifdef DOUBLE_SPH
+#include "single_photon_hit_double.h"
+#endif
+
+#ifndef DOUBLE_SPH
+#include "single_photon_hit.h"
+#endif
+
+//#include "etaInterpolationPosXY.h"
+#include "noInterpolation.h"
+#include "etaInterpolationPosXY.h"
+//#include "etaInterpolationCleverAdaptiveBins.h"
+//#include "etaInterpolationRandomBins.h"
+using namespace std;
+#define NC 400
+#define NR 400
+#define MAX_ITERATIONS (nSubPixels*100)
+
+#define XTALK
+
+int main(int argc, char *argv[]) {
+
+#ifndef FF
+  if (argc<9) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile outfile runmin runmax ns cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  
+#ifdef FF
+  if (argc<7) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile runmin runmax cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  int iarg=4;
+  char infname[10000];
+  char fname[10000];
+  char outfname[10000];
+#ifndef FF
+  iarg=4;
+#endif
+
+#ifdef FF
+  iarg=3;
+#endif
+  int runmin=atoi(argv[iarg++]);
+  int runmax=atoi(argv[iarg++]); 
+  cout << "Run min: " << runmin << endl;
+  cout << "Run max: " << runmax << endl;
+  
+  int nsubpix=4;
+#ifndef FF
+  nsubpix=atoi(argv[iarg++]);
+  cout << "Subpix: " << nsubpix << endl;
+#endif
+  float cmin=atof(argv[iarg++]);
+  float cmax=atof(argv[iarg++]);
+  cout << "Energy min: " << cmin << endl;
+  cout << "Energy max: " << cmax << endl;
+  //int etabins=500;
+  int etabins=1000;//nsubpix*2*100;
+  double etamin=-1, etamax=2;
+  //double etamin=-0.1, etamax=1.1;
+  double eta3min=-2, eta3max=2;
+  int quad;
+  double sum, totquad;
+  double sDum[2][2];
+  double etax, etay, int_x, int_y;
+  double eta3x, eta3y, int3_x, int3_y, noint_x, noint_y;
+  int ok;
+  int f0=-1;
+  int ix, iy, isx, isy;
+  int nframes=0, lastframe=-1;
+  double d_x, d_y, res=5, xx, yy;
+  int nph=0, badph=0, totph=0;
+    FILE *f=NULL;
+
+#ifdef DOUBLE_SPH
+    single_photon_hit_double cl(3,3);
+#endif
+
+#ifndef DOUBLE_SPH
+    single_photon_hit cl(3,3);
+#endif
+
+    int nSubPixels=nsubpix;
+#ifndef NOINTERPOLATION
+   eta2InterpolationPosXY *interp=new eta2InterpolationPosXY(NC, NR, nsubpix, etabins, etamin, etamax);
+   //eta2InterpolationCleverAdaptiveBins *interp=new eta2InterpolationCleverAdaptiveBins(NC, NR, nsubpix, etabins, etamin, etamax);  
+#endif
+#ifdef NOINTERPOLATION
+    noInterpolation *interp=new noInterpolation(NC, NR, nsubpix);  
+#endif
+
+
+ 
+#ifndef FF
+#ifndef NOINTERPOLATION
+    cout << "read ff " << argv[2] << endl;
+    sprintf(fname,"%s",argv[2]);
+    interp->readFlatField(fname);
+    interp->prepareInterpolation(ok);//, MAX_ITERATIONS);
+#endif
+    // return 0;
+#endif
+#ifdef FF
+    cout << "Will write eta file " << argv[2] << endl;
+#endif
+
+    int *img;
+    float *totimg=new float[NC*NR*nsubpix*nsubpix];
+    for (ix=0; ix<NC; ix++) {
+      for (iy=0; iy<NR; iy++) {
+	for (isx=0; isx<nsubpix; isx++) {
+	  for (isy=0; isy<nsubpix; isy++) {
+	    totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]=0;
+	      }
+	}
+      }
+    }
+
+#ifdef FF
+      sprintf(outfname,argv[2]);
+#endif     
+
+    int irun;
+    for (irun=runmin; irun<runmax; irun++) {
+      sprintf(infname,argv[1],irun);
+#ifndef FF
+      sprintf(outfname,argv[3],irun);
+#endif
+ 
+      f=fopen(infname,"r");
+      if (f) {
+	cout << infname << endl;
+	nframes=0;
+	f0=-1;
+
+	while (cl.read(f)) {
+	  totph++;
+	  if (lastframe!=cl.iframe) {
+	    lastframe=cl.iframe;
+	    // cout << cl.iframe << endl;
+	    // f0=cl.iframe;
+	    if (nframes==0) f0=lastframe;
+	    nframes++;
+	  }
+	  //quad=interp->calcQuad(cl.get_cluster(), sum, totquad, sDum);
+	  quad=interp->calcEta(cl.get_cluster(), etax, etay, sum, totquad, sDum);
+	    if (sum>cmin && totquad/sum>0.8 && totquad/sum<1.2 && sum<cmax ) {
+	    nph++;
+	    //  if (sum>200 && sum<580) {
+	    //  interp->getInterpolatedPosition(cl.x,cl.y, totquad,quad,cl.get_cluster(),int_x, int_y);
+// #ifdef SOLEIL
+// 	    if (cl.x>210 && cl.x<240 && cl.y>210 && cl.y<240) {
+// #endif
+#ifndef FF
+	    // interp->getInterpolatedPosition(cl.x,cl.y, cl.get_cluster(),int_x, int_y);  
+	    interp->getInterpolatedPosition(cl.x,cl.y, etax, etay, quad,int_x, int_y);
+	      // cout <<"**************"<< endl;
+	      // cout << cl.x << " " << cl.y << " " << sum << endl;
+	      // cl.print();
+	      // cout << int_x << " " << int_y << endl;
+	      // cout <<"**************"<< endl;
+	    //  if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	    interp->addToImage(int_x, int_y);
+	    if (int_x<0 || int_y<0 || int_x>400 || int_y>400) {
+	      cout <<"**************"<< endl;
+	      cout << cl.x << " " << cl.y << " " << sum << endl;
+	      cl.print();
+	      cout << int_x << " " << int_y << endl;
+	      cout <<"**************"<< endl;
+	    }
+#endif
+#ifdef FF
+	    //	interp->addToFlatField(cl.get_cluster(), etax, etay);
+// #ifdef UCL
+// 	    if (cl.x>50)
+// #endif
+// 	    if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	      interp->addToFlatField(etax, etay);
+	    //  if (etax==0 || etay==0) cout << cl.x << " " << cl.y << endl;
+	     
+#endif
+// #ifdef SOLEIL
+// 	    }
+// #endif
+	    
+	    if (nph%1000000==0) cout << nph << endl;
+	    if (nph%10000000==0) { 
+#ifndef FF
+		interp->writeInterpolatedImage(outfname);
+#endif
+#ifdef FF 
+		interp->writeFlatField(outfname);
+#endif
+		
+		}
+	  }
+	    
+	} 
+	  
+	  
+	fclose(f);
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+	
+#ifndef FF
+	interp->writeInterpolatedImage(outfname); 
+
+	img=interp->getInterpolatedImage();
+	for (ix=0; ix<NC; ix++) {
+	  for (iy=0; iy<NR; iy++) {
+	    for (isx=0; isx<nsubpix; isx++) {
+	      for (isy=0; isy<nsubpix; isy++) {
+		totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]+=img[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)];
+		}
+	    }
+	  }
+	}
+	cout << "Read " << nframes << " frames (first frame: " << f0 << " last frame: " << lastframe << " delta:" << lastframe-f0 << ") nph="<< nph <<endl;
+	interp->clearInterpolatedImage();
+#endif
+	
+      } else
+	cout << "could not open file " << infname << endl;
+    }
+#ifndef FF
+    sprintf(outfname,argv[3],11111);
+    WriteToTiff(totimg, outfname,NC*nsubpix,NR*nsubpix);
+#endif 
+    
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+
+    cout << "Filled " << nph << " (/"<< totph <<") " << endl; 
+    return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauPhotonCounter.cpp

@@ -0,0 +1,453 @@
+//#include "sls/ansi.h"
+#include <iostream>
+#define CORR
+
+#define C_GHOST 0.0004
+
+#define CM_ROWS 50
+
+//#define VERSION_V1
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedCountingDetector.h"
+//#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+#include "moench03GhostSummation.h"
+#include "moench03CommonMode.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<4) {
+    cout << "Usage is " << argv[0] << "indir outdir fname [runmin] [runmax] [pedfile] [threshold] [nframes] [xmin xmax ymin ymax] [gainmap]" << endl;
+    cout << "threshold <0 means analog; threshold=0 means cluster finder; threshold>0 means photon counting" << endl;
+    cout << "nframes <0 means sum everything; nframes=0 means one file per run; nframes>0 means one file every nframes" << endl;
+    return 1;
+  }
+
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=10;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int save=1;
+  int nsigma=5;
+  int nped=10000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+  int cf=0;
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+  int nx=400, ny=400;
+
+  decoder->getDetectorSize(nx,ny);
+
+  int ncol_cm=CM_ROWS;
+  double xt_ghost=C_GHOST;
+  moench03CommonMode *cm=NULL;
+  moench03GhostSummation *gs;
+  double *gainmap=NULL;
+  float *gm;
+
+
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+
+  int ff, np;
+  //cout << " data size is " << dsize;
+  
+
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=0;
+  
+  // cout << "argc is " << argc << endl;
+ if (argc>=5) {
+   runmin=atoi(argv[4]);
+  }
+
+ int runmax=runmin;
+
+ if (argc>=6) {
+   runmax=atoi(argv[5]);
+  }
+
+  char *pedfile=NULL;
+  if (argc>=7) {
+    pedfile=argv[6];
+  }
+  double thr=0;
+  double thr1=1;
+
+  if (argc>=8) {
+    thr=atof(argv[7]);
+  }
+  
+
+  int nframes=0;
+  
+  if (argc>=9) {
+    nframes=atoi(argv[8]);
+  }
+
+  int xmin=0, xmax=nx, ymin=0, ymax=ny;
+  if (argc>=13) {
+    xmin=atoi(argv[9]);
+    xmax=atoi(argv[10]);
+    ymin=atoi(argv[11]);
+    ymax=atoi(argv[12]);
+  }
+
+  
+  char *gainfname=NULL;
+  if (argc>13) {
+    gainfname=argv[13];
+    cout << "Gain map file name is: " << gainfname << endl;
+  }
+
+  
+
+
+  char ffname[10000];
+  char fname[10000];
+  char imgfname[10000];
+  char cfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "input file is " << fformat << endl;
+  cout << "runmin is " << runmin << endl;
+  cout << "runmax is " << runmax << endl;
+  if (pedfile)
+    cout << "pedestal file is " << pedfile << endl;
+ if (thr>0) 
+    cout << "threshold is " << thr << endl;
+ cout << "Nframes is " << nframes << endl;
+ 
+ uint32 nnx, nny;
+ double *gmap;
+
+  // if (gainfname) {
+  //   gm=ReadFromTiff(gainfname, nny, nnx);
+  //   if (gm && nnx==nx && nny==ny) {
+  //     gmap=new double[nx*ny];
+  //     for (int i=0; i<nx*ny; i++) {
+  // 	gmap[i]=gm[i];
+  //     }
+  //     delete gm;
+  //   } else
+  //     cout << "Could not open gain map " << gainfname << endl;
+  // }
+
+#ifdef CORR
+ cout << "Applying common mode  " << ncol_cm << endl;
+  cm=new moench03CommonMode(ncol_cm);
+  
+
+  cout << "Applying ghost corrections " << xt_ghost << endl;
+  gs=new moench03GhostSummation(decoder, xt_ghost);
+#endif
+
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, cm, nped, 200, -1, -1, gainmap, gs);
+
+  if (gainfname) {
+
+    if (filter->readGainMap(gainfname))
+      cout << "using gain map " << gainfname << endl;
+    else
+      cout << "Could not open gain map " << gainfname << endl;
+  } else
+    thr=0.15*thr;
+  filter->newDataSet();
+  int dsize=decoder->getDataSize();
+
+
+  char data[dsize];
+
+
+
+
+
+  //#ifndef ANALOG
+  if (thr>0) {
+    cout << "threshold is " << thr << endl;
+    //#ifndef ANALOG
+    filter->setThreshold(thr);
+    //#endif
+      cf=0;
+
+  } else
+    cf=1;
+  //#endif
+
+
+  filter->setROI(xmin,xmax,ymin,ymax);
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+
+  // multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+ multiThreadedCountingDetector *mt=new multiThreadedCountingDetector(filter,nthreads,fifosize);
+#ifndef ANALOG
+    mt->setDetectorMode(ePhotonCounting);
+    cout << "Counting!" << endl;
+  if (thr>0) {
+    cf=0;
+  } 
+#endif
+//{
+#ifdef ANALOG
+      mt->setDetectorMode(eAnalog);
+      cout << "Analog!" << endl;
+      cf=0;
+      //thr1=thr;
+#endif  
+      //  }
+  
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  //  cout << "mt " << endl;
+
+  int ifr=0;
+
+  double ped[nx*ny], *ped1;
+
+
+  if (pedfile) {
+
+    cout << "PEDESTAL " << endl;
+    sprintf(imgfname,"%s/pedestals.tiff",outdir);
+
+    if (string(pedfile).find(".tif")==std::string::npos){
+      sprintf(fname,"%s.raw",pedfile);
+      cout << fname << endl ;
+      std::time(&end_time);
+      cout << "aaa" << std::ctime(&end_time) <<   endl;
+      
+      
+      mt->setFrameMode(ePedestal);
+      // sprintf(fn,fformat,irun);
+      filebin.open((const char *)(fname), ios::in | ios::binary);
+      //      //open file
+      if (filebin.is_open()){
+	ff=-1;
+	while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	  if (np==40) {
+	    mt->pushData(buff);
+	    mt->nextThread();
+	    mt->popFree(buff);
+	    ifr++;
+	    if (ifr%100==0) 
+	      cout << ifr << " " << ff << " " << np << endl;
+	  } else
+	    cout << ifr << " " << ff << " " << np << endl;
+	  ff=-1;
+	}
+	filebin.close();	 
+	while (mt->isBusy()) {;}
+	
+      } else 
+	cout << "Could not open pedestal file "<< fname << " for reading " << endl;
+    } else {
+      float *pp=ReadFromTiff(pedfile, nny, nnx);
+      if (pp && nnx==nx && nny==ny) {
+	for (int i=0; i<nx*ny; i++) {
+	  ped[i]=pp[i];
+	}
+	delete [] pp;
+	mt->setPedestal(ped);
+	// ped1=mt->getPedestal();
+	
+	// for (int i=0; i<nx*ny; i++) {
+
+	//   cout << ped[i]<<"/"<<ped1[i] << " " ;
+	// }
+	cout << "Pedestal set from tiff file " << pedfile << endl;
+      } else {
+	cout << "Could not open pedestal tiff file "<< pedfile << " for reading " << endl;
+      }
+    }
+    mt->writePedestal(imgfname);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<   endl;
+  }
+  
+
+
+  ifr=0;
+  int ifile=0;
+  
+  mt->setFrameMode(eFrame);
+
+  for (int irun=runmin; irun<=runmax; irun++) {
+    cout << "DATA " ;
+    // sprintf(fn,fformat,irun);
+    sprintf(ffname,"%s/%s.raw",indir,fformat);
+    sprintf(fname,ffname,irun);
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    sprintf(imgfname,ffname,irun);
+    sprintf(ffname,"%s/%s.clust",outdir,fformat);
+    sprintf(cfname,ffname,irun);
+    cout << fname << " " ;
+    cout << imgfname << endl;
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    //  cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    ifile=0;
+    if (filebin.is_open()){
+      if (thr<=0 && cf!=0) { //cluster finder
+	  if (of==NULL) {
+	    of=fopen(cfname,"w");
+	    if (of) {
+	    mt->setFilePointer(of);
+	    cout << "file pointer set " << endl;
+	    } else {
+	      cout << "Could not open "<< cfname << " for writing " << endl;
+	      mt->setFilePointer(NULL);
+	      return 1;
+	    }
+	  }
+      }
+      //     //while read frame 
+      ff=-1;
+      ifr=0;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	if (np==40) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	  mt->pushData(buff);
+	  // 	//         //pop
+	  mt->nextThread();
+	  // // 		//	cout << " " << (void*)buff;
+	  mt->popFree(buff);
+
+
+
+
+	  ifr++;
+	  if (ifr%100==0) cout << ifr << " " << ff << endl;
+	  if (nframes>0) {
+	    if (ifr%nframes==0) {
+	      //The name has an additional "_fXXXXX" at the end, where "XXXXX" is the initial frame number of the image (0,1000,2000...)
+	      
+	      sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	      sprintf(imgfname,ffname,irun);
+	      //cout << "Writing tiff to " << imgfname << " " << thr1 << endl;
+	      mt->writeImage(imgfname, thr1);
+	      mt->clearImage();
+	      ifile++;
+	    }
+	  }
+	} else
+	  cout << ifr << " " << ff << " " << np << endl;
+	ff=-1;
+      }
+      cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}
+      if (nframes>=0) {
+	if (nframes>0) {
+	    sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	    sprintf(imgfname,ffname,irun);
+	} else {
+	  sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+	  sprintf(imgfname,ffname,irun);
+	}
+	cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+	mt->writeImage(imgfname, thr1);
+	mt->clearImage();
+	if (of) {
+	  fclose(of);
+	  of=NULL;
+	  mt->setFilePointer(NULL);
+	}
+      }	
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+    } else 
+      cout << "Could not open "<< fname << " for reading " << endl;
+  }
+  if (nframes<0){
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    strcpy(imgfname,ffname);
+    cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+    mt->writeImage(imgfname, thr1);
+  }
+    
+
+
+  return 0;
+}
+

slsDetectorCalibration/moenchExecutables/CMakeLists.txt

@@ -3,11 +3,11 @@ find_package(TIFF REQUIRED)
 
 #Moench ZMQ
 add_executable(moenchZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP)
+target_compile_definitions(moenchZmqProcess PRIVATE NEWZMQ INTERP)
 
 #Moench04 ZMQ
 add_executable(moench04ZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP MOENCH04)
+target_compile_definitions(moench04ZmqProcess PRIVATE NEWZMQ INTERP MOENCH04)
 
 
 #Both executables should have the same includes and output dirs
@@ -41,5 +41,9 @@ foreach(exe ${MOENCH_EXECUTABLES})
         set_property(TARGET ${exe} PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
     endif()
 
+    
+
 
 endforeach(exe ${MOENCH_EXECUTABLES})
+
+install(TARGETS ${MOENCH_EXECUTABLES} DESTINATION bin)