APRIL and SDHCALContent integration

.gitignore

@@ -0,0 +1,2 @@
+build/
+lib/

CMakeLists.txt

@@ -41,15 +41,38 @@ FIND_PACKAGE( DD4hep REQUIRED )
 FIND_PACKAGE( ROOT REQUIRED )
 FIND_PACKAGE( MarlinTrk REQUIRED )
 
+OPTION( USE_SDHCALCONTENT "Use SDHCALContent" OFF )
+OPTION( USE_APRILCONTENT "Use APRILContent" OFF )
 
-FOREACH( pkg PandoraSDK Marlin MarlinUtil  LCContent DD4hep ROOT MarlinTrk )
+FOREACH( pkg PandoraSDK Marlin MarlinUtil LCContent DD4hep ROOT MarlinTrk )
     IF( ${pkg}_FOUND )
         INCLUDE_DIRECTORIES( SYSTEM ${${pkg}_INCLUDE_DIRS} )
         LINK_LIBRARIES( ${${pkg}_LIBRARIES} )
         ADD_DEFINITIONS ( ${${pkg}_DEFINITIONS} )
     ENDIF()
 ENDFOREACH()
 
+IF( USE_SDHCALCONTENT )
+    FIND_PACKAGE( SDHCALContent REQUIRED )
+    INCLUDE_DIRECTORIES( SYSTEM ${SDHCALContent_INCLUDE_DIRS} )
+    LINK_LIBRARIES( ${SDHCALContent_LIBRARIES} )
+    ADD_DEFINITIONS ( ${SDHCALContent_DEFINITIONS} )
+    ADD_DEFINITIONS( "-DSDHCALCONTENT" )
+ENDIF()
+
+IF( USE_APRILCONTENT )
+    SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+    FIND_PACKAGE( APRILContent REQUIRED )
+    FIND_PACKAGE( mlpack REQUIRED )
+    INCLUDE_DIRECTORIES( SYSTEM ${APRILContent_INCLUDE_DIRS} )
+    LINK_LIBRARIES( ${APRILContent_LIBRARIES} )
+    ADD_DEFINITIONS ( ${APRILContent_DEFINITIONS} )
+    ADD_DEFINITIONS( "-DAPRILCONTENT" )
+    INCLUDE_DIRECTORIES( SYSTEM ${mlpack_INCLUDE_DIRS} )
+    LINK_LIBRARIES( ${mlpack_LIBRARIES} )
+    ADD_DEFINITIONS ( ${mlpack_DEFINITIONS} )
+ENDIF()
+
 IF( PANDORA_MONITORING )
     FIND_PACKAGE( PandoraMonitoring 03.00.00 REQUIRED )
     IF( PandoraMonitoring_FOUND )

README.md

@@ -16,3 +16,48 @@ DDMarlinPandora is free software: you can redistribute it and/or modify it under
 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 long with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+**The following options need to be taken into consideration only if you want to use APRIL or SDHCAL plugins. If you use DDMarlinPandora in the default configuration, you can install it the usual way.**
+
+## Options to add SDHCALContent or APRILContent
+
+Added the compilation options to choose to include SDHCALContent or APRILContent in DDMarlinPandora.
+
+Note, you should have sourced the init_ilcsoft.sh script
+
+**To compile with SDHCALContent :**
+
+1. `mkdir build`
+2. `cd build`
+3. `cmake -C ${ILCSOFT}/ILCSoft.cmake -DPANDORA_MONITORING=ON -DUSE_SDHCALCONTENT=ON -DSDHCALContent_DIR=/absolute/path/to/SDHCALContent ..`
+4. `make install`
+
+**To compile with APRILContent :**
+
+mlpack should be installed. You should use the same mlpack installation as the one used to compile APRILContent
+
+
+1. `mkdir build`
+2. `cd build`
+3. `cmake -C ${ILCSOFT}/ILCSoft.cmake -DPANDORA_MONITORING=ON -DUSE_APRILCONTENT=ON -DAPRILContent_DIR=/absolute/path/to/APRILContent -Dmlpack_DIR=/absolute/path/to/mlpack/INSTALL ..`
+4. `make install`
+
+**To compile with both SDHCALContent and APRILContent :**
+
+Combine the two cmake options above.
+
+## To run Marlin with this DDMarlinPandora :
+
+1. `echo $MARLIN_DLL`
+2. Copy the entire output of the previous command and find the part with the location of `libDDMarlinPandora.so`
+3. Replace it with the location of the DDMarlinPandora libraries you just installed and keep the rest of the output as it is
+4. `export MARLIN_DLL=/modified/output/of/echo/command`
+
+**To choose between APRIL and Pandora when calling Marlin :**
+
+1. Go to your ILDConfig folder in `ILDConfig/StandardConfig/production/ParticleFlow`
+2. Open the xml file you are using for the PFA
+3. In the section for the DDMarlinProcessor add : `<parameter name="UseAPRIL" type="bool">false</parameter>`
+4. In `ILDConfig/StandardConfig/production/PandoraSettings`, put an APRILPFA settings file
+5. To run Marlin with APRIL in `ILDConfig/StandardConfig/production`, add the following option when calling it : `--MyDDMarlinPandora.UseAPRIL="true" --constant.PandoraSettingsFile=PandoraSettings/YourAPRILSettingsFile.xml`
+

cmake/Findmlpack.cmake

@@ -0,0 +1,15 @@
+IF(NOT DEFINED mlpack_DIR)
+   MESSAGE(STATUS "Warning: it is mandorary to define mlpack_DIR.")
+ENDIF()
+
+IF (NOT DEFINED mlpack_INCLUDE_DIRS)
+  SET(mlpack_INCLUDE_DIRS ${mlpack_DIR}/include)
+ENDIF()
+
+# Check mlpack core header file
+FIND_PATH(mlpack_CORE_HPP_DIR NAMES core.hpp HINTS ${mlpack_INCLUDE_DIRS}/mlpack)
+
+# Check mlpack library
+#FIND_LIBRARY(mlpack_LIBRARIES NAMES mlpack HINTS ${mlpack_DIR}/*)
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(mlpack DEFAULT_MSG mlpack_CORE_HPP_DIR)

include/DDCaloHitCreator.h

@@ -20,10 +20,18 @@
 #include <DD4hep/Detector.h>
 #include <DD4hep/DetElement.h>
 
+#include <Pandora/PandoraObjectFactories.h>
+
+#include <memory>
 
 
 typedef std::vector<EVENT::CalorimeterHit *> CalorimeterHitVector;
 
+#ifdef APRILCONTENT
+namespace april_content { class CaloHitFactory; }
+#endif
+
+
 /**
  *  @brief  DDCaloHitCreator class
  */
@@ -111,6 +119,8 @@ class DDCaloHitCreator
         float                         m_hCalBarrelOuterPhi0;              ///< HCal barrel outer phi0 coordinate
         unsigned int                  m_hCalBarrelOuterSymmetry;          ///< HCal barrel outer symmetry order
 
+        bool m_useAPRIL = false; ///< Choose if we want to use APRIL instead of Pandora for the reconstruction
+
     public:
       FloatVector m_eCalBarrelNormalVector;
       FloatVector m_hCalBarrelNormalVector;
@@ -241,6 +251,12 @@ class DDCaloHitCreator
      */
     float GetMaximumRadius(const EVENT::CalorimeterHit *const pCaloHit, const unsigned int symmetryOrder, const float phi0) const;
 
+    /**
+     *  @brief  Initialize the factory for calo hit creation
+     * 
+     */
+    void ChooseFactory();
+
     const Settings                      m_settings;                         ///< The calo hit creator settings
 
     const pandora::Pandora &            m_pandora;                          ///< Reference to the pandora object to create calo hits
@@ -252,6 +268,12 @@ class DDCaloHitCreator
 
     dd4hep::VolumeManager m_volumeManager; ///< DD4hep volume manager
 
+    //Added by T.Pasquier
+    std::unique_ptr<pandora::ObjectFactory<object_creation::CaloHit::Parameters, object_creation::CaloHit::Object>> m_caloHitFactory{nullptr}; //General factory to initialize
+
+    /* DDCaloHitCreator& operator=(const DDCaloHitCreator&) = delete;  // Disallow copying
+    DDCaloHitCreator(const DDCaloHitCreator&) = delete; */
+
 };
 
 //------------------------------------------------------------------------------------------------------------------------------------------

include/DDPandoraPFANewProcessor.h

@@ -58,6 +58,9 @@ class DDPandoraPFANewProcessor : public marlin::Processor
         FloatVector m_ecalInputEnergyCorrectionPoints{};    ///< The input energy points for non-linearity energy correction in the ECAL
         FloatVector m_ecalOutputEnergyCorrectionPoints{};   ///< The input energy points for non-linearity energy correction in the ECAL
 
+
+        bool m_useAPRIL = false; ///< Choose if we want to use APRIL instead of Pandora for the reconstruction
+
         // Software compensation parameters
         FloatVector     m_softCompParameters{};
         FloatVector     m_softCompEnergyDensityBins{};
@@ -156,6 +159,7 @@ class DDPandoraPFANewProcessor : public marlin::Processor
      */
     void Reset();
 
+
     pandora::Pandora                     *m_pPandora = NULL;                  ///< Address of the pandora instance
     DDCaloHitCreator                     *m_pCaloHitCreator = NULL;           ///< The calo hit creator
     DDGeometryCreator                    *m_pGeometryCreator = NULL;          ///< The geometry creator
@@ -181,4 +185,11 @@ inline marlin::Processor *DDPandoraPFANewProcessor::newProcessor()
     return new DDPandoraPFANewProcessor;
 }
 
+//------------------------------------------------------------------------------------------------------------------------------------------
+//Added by T.Pasquier
+/**
+*  @brief  Register the LCContent plugins outside their original function. Temporary fix. Would be better to change the plugins registration directly in LCContent
+*/
+pandora::StatusCode APRILLCContentPluginRegistration(const pandora::Pandora &pandora);
+
 #endif // #ifndef DDPANDORAPFANEWPROCESSOR_H

src/DDCaloHitCreator.cc

@@ -13,6 +13,9 @@
 
 #include "UTIL/CellIDDecoder.h"
 
+#ifdef APRILCONTENT
+#include "APRILApi/ObjectFactories.h"
+#endif
 
 #include <DD4hep/DD4hepUnits.h>
 #include <DD4hep/DetType.h>
@@ -37,7 +40,8 @@ DDCaloHitCreator::DDCaloHitCreator(const Settings &settings, const pandora::Pand
     m_hCalBarrelLayerThickness(0.f),
     m_hCalEndCapLayerThickness(0.f),
     m_calorimeterHitVector(0),
-    m_volumeManager()
+    m_volumeManager(),
+    m_caloHitFactory()
 {
 
     const std::vector<dd4hep::rec::LayeredCalorimeterStruct::Layer>& barrelLayers= getExtension(( dd4hep::DetType::CALORIMETER | dd4hep::DetType::HADRONIC | dd4hep::DetType::BARREL), ( dd4hep::DetType::AUXILIARY  |  dd4hep::DetType::FORWARD ))->layers;
@@ -58,6 +62,8 @@ DDCaloHitCreator::DDCaloHitCreator(const Settings &settings, const pandora::Pand
      m_volumeManager = theDetector.volumeManager();
    }
 
+   ChooseFactory();
+
 }
 
 //------------------------------------------------------------------------------------------------------------------------------------------
@@ -94,7 +100,7 @@ pandora::StatusCode DDCaloHitCreator::CreateECalCaloHits(const EVENT::LCEvent *c
             if (0 == nElements)
                 continue;
 
-	    streamlog_out( DEBUG1 ) << "Creating " << *iter << " hits" << std::endl;
+	        streamlog_out( DEBUG1 ) << "Creating " << *iter << " hits" << std::endl;
 
             const std::vector<dd4hep::rec::LayeredCalorimeterStruct::Layer>& barrelLayers= getExtension( ( dd4hep::DetType::CALORIMETER | dd4hep::DetType::ELECTROMAGNETIC | dd4hep::DetType::BARREL), ( dd4hep::DetType::AUXILIARY  |  dd4hep::DetType::FORWARD ) )->layers;
             const std::vector<dd4hep::rec::LayeredCalorimeterStruct::Layer>& endcapLayers= getExtension( ( dd4hep::DetType::CALORIMETER | dd4hep::DetType::ELECTROMAGNETIC | dd4hep::DetType::ENDCAP), ( dd4hep::DetType::AUXILIARY  |  dd4hep::DetType::FORWARD ) )->layers;
@@ -195,7 +201,8 @@ pandora::StatusCode DDCaloHitCreator::CreateECalCaloHits(const EVENT::LCEvent *c
                         caloHitParameters.m_cellSize1 = splitCellSize;
                     }
 
-                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters));
+                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters, *m_caloHitFactory));
+
                     m_calorimeterHitVector.push_back(pCaloHit);
 
                 }
@@ -283,7 +290,8 @@ pandora::StatusCode DDCaloHitCreator::CreateHCalCaloHits(const EVENT::LCEvent *c
                     caloHitParameters.m_hadronicEnergy = std::min(m_settings.m_hCalToHadGeV * pCaloHit->getEnergy(), m_settings.m_maxHCalHitHadronicEnergy);
                     caloHitParameters.m_electromagneticEnergy = m_settings.m_hCalToEMGeV * pCaloHit->getEnergy();
 
-                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters));
+                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters, *m_caloHitFactory));
+
                     m_calorimeterHitVector.push_back(pCaloHit);
                 }
                 catch (pandora::StatusCodeException &statusCodeException)
@@ -385,7 +393,8 @@ pandora::StatusCode DDCaloHitCreator::CreateMuonCaloHits(const EVENT::LCEvent *c
                         caloHitParameters.m_mipEquivalentEnergy = pCaloHit->getEnergy() * m_settings.m_muonToMip;
                     }
 
-                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters));
+                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters, *m_caloHitFactory));
+
                     m_calorimeterHitVector.push_back(pCaloHit);
                 }
                 catch (pandora::StatusCodeException &statusCodeException)
@@ -459,7 +468,8 @@ pandora::StatusCode DDCaloHitCreator::CreateLCalCaloHits(const EVENT::LCEvent *c
                     caloHitParameters.m_electromagneticEnergy = m_settings.m_eCalToEMGeV * pCaloHit->getEnergy();
                     caloHitParameters.m_hadronicEnergy = m_settings.m_eCalToHadGeVEndCap * pCaloHit->getEnergy();
 
-                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters));
+                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters, *m_caloHitFactory));
+
                     m_calorimeterHitVector.push_back(pCaloHit);
                 }
                 catch (pandora::StatusCodeException &statusCodeException)
@@ -532,7 +542,8 @@ pandora::StatusCode DDCaloHitCreator::CreateLHCalCaloHits(const EVENT::LCEvent *
                     caloHitParameters.m_hadronicEnergy = std::min(m_settings.m_hCalToHadGeV * pCaloHit->getEnergy(), m_settings.m_maxHCalHitHadronicEnergy);
                     caloHitParameters.m_electromagneticEnergy = m_settings.m_hCalToEMGeV * pCaloHit->getEnergy();
 
-                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters));
+                    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(m_pandora, caloHitParameters, *m_caloHitFactory));
+
                     m_calorimeterHitVector.push_back(pCaloHit);
                 }
                 catch (pandora::StatusCodeException &statusCodeException)
@@ -804,6 +815,22 @@ float DDCaloHitCreator::GetMaximumRadius(const EVENT::CalorimeterHit *const pCal
     return maximumRadius;
 }
 
+//------------------------------------------------------------------------------------------------------------------------------------------
+//Added by T. Pasquier
+void DDCaloHitCreator::ChooseFactory()
+{
+    #ifdef APRILCONTENT
+    if(m_settings.m_useAPRIL)
+    {   
+        m_caloHitFactory = std::make_unique<april_content::CaloHitFactory>();
+    }
+    else
+    #endif
+    {
+        m_caloHitFactory = std::make_unique<pandora::PandoraObjectFactory<object_creation::CaloHit::Parameters, object_creation::CaloHit::Object>>();
+    }
+}
+
 //------------------------------------------------------------------------------------------------------------------------------------------
 //------------------------------------------------------------------------------------------------------------------------------------------