KVReconstructedEvent.cpp

/***************************************************************************
                          kvreconstructedevent.cpp  -  description
                             -------------------
    begin                : March 11th 2005
    copyright            : (C) 2005 by J.D. Frankland
    email                : frankland@ganil.fr
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "KVReconstructedEvent.h"
#include "KVDetectorEvent.h"
#include "KVGroup.h"
#include "Riostream.h"
#include "KVReconstructedNucleus.h"
#include "KVDetector.h"
#include "KVTarget.h"
#include "KVMultiDetArray.h"
#include <iomanip>
 
using namespace std;
 
ClassImp(KVReconstructedEvent)
 
 
 
void KVReconstructedEvent::init()
{
   //default initialisations
   UseRandomAngles();
   fPartSeedCond = "all";
}
 
 
 
 
KVReconstructedEvent::KVReconstructedEvent(Int_t mult): KVTemplateEvent(mult)
{
   init();
   CustomStreamer();            //because KVReconstructedNucleus has a customised streamer
}
 
 
 
 
 
void KVReconstructedEvent::Streamer(TBuffer& R__b)
{
   // Stream an object of class KVReconstructedEvent.
   //
   // If the KVMultiDetArray corresponding to the event has been built, we:
   //
   //  - set the values of raw data parameters in the corresponding detectors
   //
   //  - set the particles' angles depending on whether mean or random angles
   //    are wanted (fMeanAngles = kTRUE or kFALSE)
 
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(KVReconstructedEvent::Class(), this);
      // if the multidetector object exists, update some informations
      // concerning the detectors etc. hit by this particle
      if (gMultiDetArray) {
         // reset raw data in detectors if found in parameter list
         gMultiDetArray->SetRawDataFromReconEvent(fParameters);
         //set angles
         KVReconstructedNucleus* par;
         for (KVReconstructedEvent::Iterator it = begin(); it != end(); ++it) {
            par = it.get_pointer();
            if (HasMeanAngles())
               par->GetAnglesFromReconstructionTrajectory("mean");
            else
               par->GetAnglesFromReconstructionTrajectory("random");
 
            // apply identification & calibration code selection
            gMultiDetArray->AcceptParticleForAnalysis(par);
         }
      }
   }
   else {
      R__b.WriteClassBuffer(KVReconstructedEvent::Class(), this);
   }
}
 
 
 
 
 
 
 
void KVReconstructedEvent::Print(Option_t* option) const
{
   // Print out detailed information on each particle in the event.
   //
   // \param[in] option if given, will be used as argument to GetNextParticleIterator() to limit
   //                   particles shown to those which correspond to the given criteria. This also
   //                   affects the displayed event multiplicity.
 
   cout << "     ***//***  RECONSTRUCTED EVENT #" << GetNumber() << "  ***//***" << endl;
   cout << GetTitle() << endl;  //system
   cout << GetName() << endl;   //run
   cout << "MULTIPLICITY = " << ((KVReconstructedEvent*) this)->
        GetMult(option) << endl << endl;
 
   int i = 1;
   for (auto it = GetNextParticleIterator(option); it != end(); ++it) {
      auto& frag = it.get_const_reference();
      cout << "RECONSTRUCTED PARTICLE #" << i++ << endl;
      frag.Print();
      cout << endl;
   }
 
}
 
 
 
 
void KVReconstructedEvent::ls(Option_t* option) const
{
   // Print out compact listing of all particles in event.
   //
   // \param[in] option if given, will be used as argument to GetNextParticleIterator() to limit
   //                   particles shown to those which correspond to the given criteria. This also
   //                   affects the displayed event multiplicity.
 
   printf(":::%s   #%07d    M=%03d\n", ClassName(), GetNumber(), GetMult());
   GetParameters()->Print();
   int i(1);
   for (auto it = GetNextParticleIterator(option); it != end(); ++it) {
      auto& nuc = it.get_const_reference();
      printf(" %3d", i);
      nuc.ls();
      ++i;
   }
}
 
 
 
 
void KVReconstructedEvent::MergeEventFragments(TCollection* events, Option_t* opt)
{
   // Merge all events in the list into one event (this one)
   // First we clear this event, then we fill it with copies of each particle in each event
   // in the list.
   // If option "opt" is given, it is given as argument to each call to
   // KVEvent::Clear() - this option is then passed on to the Clear()
   // method of each particle in each event.
   // NOTE: the events in the list will be empty and useless after this!
   //
   // This method overrides the one defined in KVEvent. As KVReconstructedNucleus objects
   // are referenced by the detectors used in their reconstruction, we also have to update
   // the references in the detectors otherwise they will still reference the particles
   // in the events in the list, which will no longer be valid after this operation.
 
   Clear(opt);
   TIter it(events);
   KVReconstructedEvent* e;
   while ((e = (KVReconstructedEvent*)it())) {
      if (e->GetMult()) {
         for (auto& n : ReconEventIterator(e)) {
            AddParticle()->CopyAndMoveReferences(&n);
         }
      }
      GetParameters()->Merge(*(e->GetParameters()));
      e->Clear(opt);
   }
}