KVEvent.h

#ifndef KVBASEEVENT_H
#define KVBASEEVENT_H
 
#include <KVBase.h>
#include <TTree.h>
#include "KVNameValueList.h"
#include "TClonesArray.h"
class KVFrameTransform;
class KVParticle;
class KVNucleus;
 
#include <TH1.h>
#include <iterator>
 
class KVIntegerList;
 
class KVEvent: public KVBase {
 
protected:
 
    TClonesArray* fParticles;
    KVNameValueList fParameters;
 
#ifdef __WITHOUT_TCA_CONSTRUCTED_AT
   TObject* ConstructedAt(Int_t idx)
   {
 
      TObject* obj = (*fParticles)[idx];
      if (obj && obj->TestBit(TObject::kNotDeleted)) {
         return obj;
      }
      return (fParticles->GetClass()) ? static_cast<TObject*>(fParticles->GetClass()->New(obj)) : 0;
   }
   TObject* ConstructedAt(Int_t idx, Option_t* clear_options)
   {
 
      TObject* obj = (*fParticles)[idx];
      if (obj && obj->TestBit(TObject::kNotDeleted)) {
         obj->Clear(clear_options);
         return obj;
      }
      return (fParticles->GetClass()) ? static_cast<TObject*>(fParticles->GetClass()->New(obj)) : 0;
   }
#endif
 
public:
   KVEvent(const TClass* particle_class, Int_t mult = 50)
      :  fParticles(new TClonesArray(particle_class, mult)),
         fParameters("EventParameters", "Parameters associated with an event")
   {
      CustomStreamer();
   }
   virtual ~KVEvent()
   {
 
      fParticles->Delete();
      SafeDelete(fParticles);
   }
 
   void Copy(TObject& obj) const;
 
   const TClonesArray* GetParticleArray() const
   {
      return fParticles;
   }
   virtual Int_t GetMult(Option_t* opt = "") const
   {
 
      (void)opt;
      return fParticles->GetEntriesFast();
   }
   virtual KVParticle* GetNextParticle(Option_t* = "") const = 0;
   virtual void ResetGetNextParticle() const = 0;
   virtual KVParticle* GetParticle(Int_t npart) const = 0;
   virtual KVParticle* AddParticle() = 0;
 
   KVNucleus* GetNextNucleus(Option_t* opt = "") const;
   void ResetGetNextNucleus() const
   {
      ResetGetNextParticle();
   }
   KVNucleus* GetNucleus(Int_t npart) const;
   KVNucleus* AddNucleus();
 
   virtual void SetFrame(const Char_t*, const KVFrameTransform&) = 0;
   virtual void SetFrame(const Char_t*, const Char_t*, const KVFrameTransform&) = 0;
   virtual void MergeEventFragments(TCollection* events, Option_t* opt = "");
 
   void CustomStreamer()
   {
      fParticles->BypassStreamer(kFALSE);
   }
 
   KVNameValueList* GetParameters() const
   {
      return (KVNameValueList*)&fParameters;
   }
 
   virtual Double_t GetSum(const Char_t*, Option_t* = "") = 0;
   virtual Double_t GetChannelQValue() const = 0;
   virtual KVString GetPartitionName() = 0;
   virtual void SetFrameName(const KVString& name) = 0;
   virtual void ChangeDefaultFrame(const Char_t*, const Char_t* = "") = 0;
   const Char_t* GetFrameName() const
   {
 
      return (GetParameters()->HasStringParameter("defaultFrame") ?
              GetParameters()->GetStringValue("defaultFrame") : "");
   }
   template<typename ValType> void SetParameter(const Char_t* name, ValType value) const
   {
 
      GetParameters()->SetValue(name, value);
   }
   virtual void GetMasses(std::vector<Double_t>&) = 0;
 
#define KVEVENT_MAKE_EVENT_BRANCH_NO_VOID_PTR 1
   template<typename T>
   static void MakeEventBranch(TTree* tree, const TString& branchname, T& event, Int_t bufsize = 10000000)
   {
 
      tree->Branch(branchname, event->ClassName(), &event, bufsize, 0)->SetAutoDelete(kFALSE);
   }
   static KVEvent* Factory(const char* plugin)
   {
 
      TPluginHandler* ph = LoadPlugin("KVEvent", plugin);
      if (ph) {
         return (KVEvent*)ph->ExecPlugin(0);
      }
      return nullptr;
   }
   void Clear(Option_t* opt = "")
   {
 
      if (strcmp(opt, "")) { // pass options to particle class Clear() method
         TString Opt = Form("C+%s", opt);
         fParticles->Clear(Opt);
      }
      else
         fParticles->Clear("C");
      fParameters.Clear();
      ResetGetNextParticle();
   }
 
   ClassDef(KVEvent, 4)
};
 
#endif // KVBASEEVENT_H