KVExpSetUp.h

 
 
#ifndef __KVEXPSETUP_H
#define __KVEXPSETUP_H
 
#include "KVMultiDetArray.h"
#include <KVExpDB.h>
class KVDBRun;
 
class KVExpSetUp : public KVMultiDetArray {
 
   void for_each_array(const std::function<void(KVMultiDetArray*)>& f,
                       const std::function<bool(KVMultiDetArray*)>& break_cond = [](KVMultiDetArray*)
   {
      return false;
   })
   const
   {
      TIter next_array(&fMDAList);
      KVMultiDetArray* mda;
      while ((mda = (KVMultiDetArray*)next_array())) {
         f(mda);
         if (break_cond(mda)) break;
      }
   }
 
protected:
    KVList fMDAList;
   KVString lmultidetarrayclasses;
 
   void init();
 
#ifdef WITH_MFM
   Bool_t handle_raw_data_event_mfmframe(const MFMCommonFrame& mfmframe)
   {
 
      Bool_t return_value = kFALSE;
      for_each_array(
      [](KVMultiDetArray*) {},
      [&](KVMultiDetArray * mda) {
         if (mda->handle_raw_data_event_mfmframe(mfmframe)) {
            mda->fHandledRawData = true;
            return_value = kTRUE;
         }
         return return_value;
      }
      );
      return return_value;
   }
#endif
   void copy_fired_parameters_to_recon_param_list()
   {
      for_each_array([](KVMultiDetArray * mda) {
         if (mda->HandledRawData()) mda->copy_fired_parameters_to_recon_param_list();
      }
                    );
   }
 
   virtual void SetExpectedDetectorSignalNames()
   {
      for_each_array([](KVMultiDetArray * mda) {
         mda->SetExpectedDetectorSignalNames();
      }
                    );
   }
 
public:
 
   KVExpSetUp();
   virtual ~KVExpSetUp();
   virtual void Build(Int_t run = -1);
   void Clear(Option_t* opt = "")
   {
 
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->Clear(opt);
      });
   }
 
   void FillDetectorList(KVReconstructedNucleus* rnuc, KVHashList* DetList, const KVString& DetNames)
   {
 
      for_each_array(
      [ = ](KVMultiDetArray * mda) {
         mda->FillDetectorList(rnuc, DetList, DetNames);
      },
      [ = ](KVMultiDetArray*) {
         return !DetList->IsEmpty();
      }
      );
   }
   virtual KVMultiDetArray* GetArray(const Char_t* name) const
   {
      return (KVMultiDetArray*)fMDAList.FindObject(name);
   }
   virtual void AcceptParticleForAnalysis(KVReconstructedNucleus*) const;
 
   void GetDetectorEvent(KVDetectorEvent* detev, const TSeqCollection* fired_params = nullptr)
   {
 
      for_each_array(
      [ = ](KVMultiDetArray * mda) {
         mda->GetDetectorEvent(detev, fired_params);
      }
      );
   }
   KVGroupReconstructor* GetReconstructorForGroup(const KVGroup* g) const
   {
 
      KVGroupReconstructor* gr(nullptr);
      for_each_array(
      [ =, &gr](KVMultiDetArray * mda) {
         gr = mda->GetReconstructorForGroup(g);
      },
      [ =, &gr ](KVMultiDetArray * mda) {
         return gr != nullptr;
      }
      );
      return gr;
   }
   void SetRawDataFromReconEvent(KVNameValueList& l)
   {
      prepare_to_handle_new_raw_data();
      for_each_array([&](KVMultiDetArray * mda) {
         mda->SetRawDataFromReconEvent(l);
      });
   }
 
   void GetArrayMultiplicities(KVReconstructedEvent*, KVNameValueList&, Option_t* = "");
 
   void MakeCalibrationTables(KVExpDB* db)
   {
      TString orig_dbtype = db->GetDBType();
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->MakeCalibrationTables(db);
      }
                    );
      db->SetDBType(orig_dbtype);
   }
   void SetCalibratorParameters(KVDBRun* r, const TString& = "")
   {
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->SetCalibratorParameters(r, mda->GetName());
      }
                    );
   }
   void SetDetectorParametersForRun(KVDBRun* r, const TString& = "")
   {
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->SetCurrentRunNumber(r->GetNumber());
         mda->SetDetectorParametersForRun(r, mda->GetName());
      }
                    );
   }
 
   virtual void AcceptAllIDCodes()
   {
 
      for_each_array([](KVMultiDetArray * mda) {
         mda->AcceptAllIDCodes();
      }
                    );
   }
   virtual void AcceptAllECodes()
   {
 
      for_each_array([](KVMultiDetArray * mda) {
         mda->AcceptAllECodes();
      }
                    );
   }
 
   virtual void InitializeIDTelescopes()
   {
 
      for_each_array([](KVMultiDetArray * mda) {
         mda->InitializeIDTelescopes();
      }
                    );
   }
 
   void InitialiseRawDataReading(KVRawDataReader* R)
   {
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->InitialiseRawDataReading(R);
      }
                    );
   }
   Bool_t HandleRawDataEvent(KVRawDataReader*);
 
   virtual void SetSimMode(Bool_t on = kTRUE)
   {
 
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->SetSimMode(on);
      }
                    );
   }
   virtual void SetTarget(KVTarget* target)
   {
 
      KVMultiDetArray::SetTarget(target);
      for_each_array([ = ](KVMultiDetArray * mda) {
         mda->SetTarget(target);
      }
                    );
   }
 
   ClassDef(KVExpSetUp, 1) //Describe an experimental set-up made of several KVMultiDetArray objects
};
 
#endif