AtMCFitter.h

Go to the documentation of this file.

#ifndef ATMCFITTER_H
#define ATMCFITTER_H
 
#include "AtEvent.h"
#include "AtMCResult.h" // for AtMCResult
#include "AtRawEvent.h"
 
#include <TClonesArray.h> // for TClonesArray
 
#include <functional> // for function
#include <map>        // for map
#include <memory>     // for shared_ptr
#include <mutex>      // for mutex
#include <set>        // for set
#include <string>     // for string
#include <utility>    // for pair
#include <vector>     // for vector
 
class AtBaseEvent;        // lines 13-13
class AtClusterize;       // lines 15-15
class AtMap;              // lines 18-18
class AtPatternEvent;     // lines 12-12
class AtPulse;            // lines 16-16
class AtSimpleSimulation; // lines 14-14
class AtDigiPar;
class AtPSA;
 
namespace MCFitter {
class AtParameterDistribution;
 
class AtMCFitter {
protected:
   using ParamPtr = std::shared_ptr<AtParameterDistribution>;
   using SimPtr = std::shared_ptr<AtSimpleSimulation>;
 
   using ClusterPtr = std::shared_ptr<AtClusterize>;
   using PulsePtr = std::shared_ptr<AtPulse>;
   using MapPtr = std::shared_ptr<AtMap>;
   using PsaPtr = std::shared_ptr<AtPSA>;
   using ObjPair = std::pair<int, double>; //< Iteration number and objective function value
 
   std::map<std::string, ParamPtr> fParameters;
 
   MapPtr fMap;
   SimPtr fSim;
   ClusterPtr fClusterize;
   PulsePtr fPulse;
   PsaPtr fPSA{nullptr};
 
   int fNumIter{1};
   int fNumRounds{1};
   int fNumEventsToSave{10};
   bool fTimeEvent{false};
   int fNumThreads{1};
 
   // Things used by threads excecuting that are either expensive to create and delete
   // or unaccessable due to FairRoot design choices
   const AtPatternEvent *fCurrentEvent{nullptr};
   std::vector<PulsePtr> fThPulse; //< Cached because it is expensive to create and delete.
   const AtDigiPar *fPar{nullptr}; //<Tracked sepretly because FairRun::Instance is thread local.
 
   // These are not locked by the mutex since we ensure no realloc of the vector is happening and
   // each thread is accessing a discrete subset of the elements of these vectors
   std::vector<AtRawEvent> fRawEventArray;
   std::vector<AtEvent> fEventArray;
 
   std::mutex fResultMutex;
   std::set<AtMCResult, std::function<bool(AtMCResult, AtMCResult)>> fResults;
 
public:
   AtMCFitter(SimPtr sim, ClusterPtr cluster, PulsePtr pulse);
   virtual ~AtMCFitter() = default;
 
   void Init();
   void SetPSA(PsaPtr psa) { fPSA = psa; }
   void Exec(const AtPatternEvent &event);
 
   ParamPtr GetParameter(const std::string &name) const;
   void FillResultArrays(TClonesArray &resultArray, TClonesArray &simEvent, TClonesArray &simRawEvent);
   void SetNumIter(int iter) { fNumIter = iter; }
 
   void SetNumRounds(int rounds) { fNumRounds = rounds; }
   void SetTimeEvent(bool val) { fTimeEvent = val; }
   void SetNumEventsToSave(int num) { fNumEventsToSave = num; }
   void SetNumThreads(int num);
 
protected:
   void RunRound();
   void RunIterRange(int startIter, int numIter, AtPulse *pulse);
 
   virtual void CreateParamDistros() = 0;
 
   virtual void SetParamDistributions(const AtPatternEvent &event) = 0;
 
   virtual double ObjectiveFunction(const AtBaseEvent &expEvent, int SimEventID, AtMCResult &definition) = 0;
 
   virtual TClonesArray SimulateEvent(AtMCResult &definition) = 0;
 
   virtual AtMCResult DefineEvent();
 
   virtual void RecenterParamDistributions();
 
   int DigitizeEvent(const TClonesArray &points, int idx, AtPulse *pulse);
};
 
} // namespace MCFitter
 
#endif // ATMCFITTER_H