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) 

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

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/firmware.rst

@@ -154,6 +154,8 @@ 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
@@ -222,6 +224,8 @@ Download
 Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Always ensure that the client and server software are of the same release.
+
 #. Program from console
     .. code-block:: bash
 
@@ -251,6 +255,8 @@ Download
 Upgrade (from v5.0.0)
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Always ensure that the client and server software are of the same release.
+
 #. Program from console
     .. code-block:: bash
 
@@ -278,6 +284,8 @@ 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
 
@@ -304,6 +312,8 @@ 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
 
@@ -344,26 +354,43 @@ Firmware Troubleshooting with blackfin
 
 5. If one can't list it, read the next section to try to get the blackfin to list it.
 
-How to get back mtd3 drive remotely
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-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

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

python/examples/use_currentsource.py

@@ -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/using_scan.py

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

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)
 
+
+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

@@ -20,4 +20,5 @@ from .enums import *
 
 IpAddr = _slsdet.IpAddr
 MacAddr = _slsdet.MacAddr
-scanParameters = _slsdet.scanParameters
+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
@@ -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()
@@ -1627,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):
@@ -1749,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)
 
@@ -1787,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):
@@ -1828,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
@@ -1971,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):
@@ -1981,14 +2032,39 @@ 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
@@ -2008,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)
         """
@@ -2027,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()
 
@@ -2041,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
 
@@ -2133,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>>>---------------------------
     """
@@ -2161,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):
         """
@@ -2212,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.
@@ -2332,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
     """
@@ -2381,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
         -----------
@@ -2521,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

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/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,
@@ -156,6 +160,13 @@ void init_det(py::module &m) {
              (void (Detector::*)(const bool)) &
                  Detector::setGapPixelsinCallback,
              py::arg())
+        .def("getFlipRows",
+             (Result<bool>(Detector::*)(sls::Positions) const) &
+                 Detector::getFlipRows,
+             py::arg() = Positions{})
+        .def("setFlipRows",
+             (void (Detector::*)(bool, sls::Positions)) & Detector::setFlipRows,
+             py::arg(), py::arg() = Positions{})
         .def("isVirtualDetectorServer",
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::isVirtualDetectorServer,
@@ -243,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,
@@ -354,9 +368,28 @@ void init_det(py::module &m) {
              py::arg(), py::arg() = Positions{})
         .def("getDacList", (std::vector<defs::dacIndex>(Detector::*)() const) &
                                Detector::getDacList)
-        .def("setDefaultDacs",
-             (void (Detector::*)(sls::Positions)) & Detector::setDefaultDacs,
-             py::arg() = Positions{})
+        .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) &
@@ -393,6 +426,39 @@ 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)
@@ -401,7 +467,9 @@ void init_det(py::module &m) {
         .def("startDetector", (void (Detector::*)()) & Detector::startDetector)
         .def("startDetectorReadout",
              (void (Detector::*)()) & Detector::startDetectorReadout)
-        .def("stopDetector", (void (Detector::*)()) & Detector::stopDetector)
+        .def("stopDetector",
+             (void (Detector::*)(sls::Positions)) & Detector::stopDetector,
+             py::arg() = Positions{})
         .def("getDetectorStatus",
              (Result<defs::runStatus>(Detector::*)(sls::Positions) const) &
                  Detector::getDetectorStatus,
@@ -428,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,
@@ -491,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,
@@ -827,13 +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("getRateCorrection",
              (Result<sls::ns>(Detector::*)(sls::Positions) const) &
                  Detector::getRateCorrection,
@@ -846,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,
@@ -878,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,
@@ -911,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,
@@ -935,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) &
@@ -967,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,
@@ -1042,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) &
@@ -1074,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) &
@@ -1132,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,
@@ -1213,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,

python/src/enums.cpp

@@ -210,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)
@@ -230,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)
@@ -253,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")
@@ -277,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/main.cpp

@@ -21,6 +21,7 @@ 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
@@ -37,6 +38,7 @@ PYBIND11_MODULE(_slsdet, m) {
      init_network(m);
      init_pattern(m);
      init_scan(m);
+     init_source(m);
     //  init_experimental(m);
     
 

serverBin/ctbDetectorServer_developer

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

serverBin/ctbDetectorServerv6.0.0-rc1

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

serverBin/eigerDetectorServer_developer

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

serverBin/eigerDetectorServerv6.0.0-rc1

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

serverBin/gotthard2DetectorServer_developer

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

serverBin/gotthard2DetectorServerv6.0.0-rc1

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

serverBin/gotthardDetectorServer_developer

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

serverBin/gotthardDetectorServerv6.0.0-rc1

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

serverBin/jungfrauDetectorServer_developer

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

serverBin/jungfrauDetectorServerv6.0.0-rc1

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

serverBin/moenchDetectorServer_developer

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

serverBin/moenchDetectorServerv6.0.0-rc1

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

serverBin/mythen3DetectorServer_developer

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

serverBin/mythen3DetectorServerv6.0.0-rc1

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

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;