// @(#)root/proofplayer:$Id$
// Author: G. Ganis Jan 2010

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
*************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPacketizerMulti                                                     //
//                                                                      //
// This class allows to do multiple runs in the same query; each run    //
// can be a, for example, different dataset or the same dataset with    //
// entry list.                                                          //
// The multiple packetizer conatins a list of packetizers which are     //
// processed in turn.                                                   //
// The bit TSelector::kNewRun is set in the TSelector object when a new //
// packetizer is used.                                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#include "TPacketizerMulti.h"

#include "TClass.h"
#include "TDSet.h"
#include "TError.h"
#include "TFileInfo.h"
#include "TList.h"
#include "TMap.h"
#include "TMethodCall.h"
#include "TProof.h"
#include "TProofDebug.h"

ClassImp(TPacketizerMulti)

//______________________________________________________________________________
TPacketizerMulti::TPacketizerMulti(TDSet *dset, TList *wrks,
                                   Long64_t first, Long64_t num,
                                   TList *input, TProofProgressStatus *st)
                 : TVirtualPacketizer(input, st)
{
   // Constructor

   PDB(kPacketizer,1) Info("TPacketizerMulti",
                           "enter (first %lld, num %lld)", first, num);
   fValid = kFALSE;
   fPacketizersIter = 0;
   fCurrent = 0;
   fAssignedPack = 0;

   // Check inputs
   if (!dset || !wrks || !input || !st) {
      Error("TPacketizerMulti", "invalid inputs: dset:%p wrks:%p input:%p st:%p",
                                dset, wrks, input, st);
      return;
   }
   // Create the list
   fPacketizers = new TList;

   // We do not want progress timers from the single packetizers
   TNamed *progTimerFlag = new TNamed("PROOF_StartProgressTimer", "no");
   input->Add(progTimerFlag);

   fTotalEntries = 0;
   TVirtualPacketizer *packetizer = 0;
   // Simple or multi?
   if (!(dset->TestBit(TDSet::kMultiDSet))) {
      if ((packetizer = CreatePacketizer(dset, wrks, first, num, input, st))) {
         fPacketizers->Add(packetizer);
         fTotalEntries = packetizer->GetTotalEntries();
      } else {
         Error("TPacketizerMulti", "problems initializing packetizer for single dataset");
         input->Remove(progTimerFlag);
         delete progTimerFlag;
         return;
      }
   } else {
      // Iterate on the datasets
      TIter nxds(dset->GetListOfElements());
      TDSet *ds = 0;
      while ((ds = (TDSet *)nxds())) {
         if ((packetizer = CreatePacketizer(ds, wrks, first, num, input, st))) {
            fPacketizers->Add(packetizer);
            fTotalEntries += packetizer->GetTotalEntries();
         } else {
            Error("TPacketizerMulti", "problems initializing packetizer for dataset '%s'", ds->GetName());
         }
      }
   }
   // Cleanup temporary additions to the input list
   input->Remove(progTimerFlag);
   delete progTimerFlag;

   // If no valid packetizer could be initialized we fail
   if (fPacketizers->GetSize() <= 0) {
      Error("TPacketizerMulti", "no valid packetizer could be initialized - aborting");
      SafeDelete(fPacketizers);
      return;
   } else {
      Info("TPacketizerMulti", "%d packetizer(s) have been successfully initialized (%lld events in total)",
                               fPacketizers->GetSize(), fTotalEntries);
      // To avoid problems with counters we must set the total entries in each packetizer
      TIter nxp(fPacketizers);
      while ((packetizer = (TVirtualPacketizer *) nxp()))
         packetizer->SetTotalEntries(fTotalEntries);
   }

   // Create the interator
   fPacketizersIter = new TIter(fPacketizers);

   // Set the current the first
   if (!(fCurrent = (TVirtualPacketizer *) fPacketizersIter->Next())) {
      // Weird
      Error("TPacketizerMulti", "could not point to the first valid packetizer");
      fPacketizers->SetOwner(kTRUE);
      SafeDelete(fPacketizers);
      SafeDelete(fPacketizersIter);
      return;
   }

   // Create map
   fAssignedPack = new TMap;

   // Ok, everything went fine
   fValid = kTRUE;

   PDB(kPacketizer,1) Info("TPacketizerMulti", "done");
}

//______________________________________________________________________________
TPacketizerMulti::~TPacketizerMulti()
{
   // Destructor.

   if (fPacketizers) {
      fPacketizers->SetOwner(kTRUE);
      SafeDelete(fPacketizers);
   }
   SafeDelete(fPacketizers);
   fCurrent = 0;
   if (fAssignedPack) {
      fAssignedPack->SetOwner(kFALSE);
      SafeDelete(fAssignedPack);
   }
   SafeDelete(fPacketizersIter);
}

//______________________________________________________________________________
TDSetElement *TPacketizerMulti::GetNextPacket(TSlave *wrk, TMessage *r)
{
   // Get next packet from the current packetizer.
   // If the current packetizer is done, move to next.
   // Retun null when all packetizers are done.

   TDSetElement *elem = 0;

   // Must be valid
   if (!fValid) return elem;

   // Point to the packetizer last used for thsi worker
   TVirtualPacketizer *lastPacketizer = dynamic_cast<TVirtualPacketizer *>(fAssignedPack->GetValue(wrk));
   if (lastPacketizer && lastPacketizer != fCurrent) {
      PDB(kPacketizer,2)
         Info("GetNextPacket", "%s: asking old packetizer %p ... ", wrk->GetOrdinal(), lastPacketizer);
      if ((elem = lastPacketizer->GetNextPacket(wrk, r))) return elem;
      if (fCurrent) {
         // Transfer the status info
         TVirtualSlaveStat *oldstat = dynamic_cast<TVirtualSlaveStat *>(lastPacketizer->GetSlaveStats()->GetValue(wrk));
         TVirtualSlaveStat *curstat = dynamic_cast<TVirtualSlaveStat *>(fCurrent->GetSlaveStats()->GetValue(wrk));
         if (oldstat && curstat)
            *(curstat->GetProgressStatus()) += *(oldstat->GetProgressStatus());
      }
   }

   // Need something to be processed
   if (!fCurrent) {
      HandleTimer(0);   // Send last timer message
      return elem;
   }

   // Get the next packet from the current packetizer
   PDB(kPacketizer,2)
      Info("GetNextPacket", "%s: asking current packetizer %p ... ", wrk->GetOrdinal(), fCurrent);
   if (!(elem = fCurrent->GetNextPacket(wrk, r))) {
      // We need to transfer the status info if we change packetizer now
      TMap *oldStats = (lastPacketizer && lastPacketizer == fCurrent) ? lastPacketizer->GetSlaveStats() : 0;
      // If the packetizer is done, move to next
      fCurrent = (TVirtualPacketizer *) fPacketizersIter->Next();
      if (fCurrent) {
         // Transfer the status info
         if (oldStats) {
            TVirtualSlaveStat *oldstat = dynamic_cast<TVirtualSlaveStat *>(oldStats->GetValue(wrk));
            TVirtualSlaveStat *curstat = dynamic_cast<TVirtualSlaveStat *>(fCurrent->GetSlaveStats()->GetValue(wrk));
            if (oldstat && curstat)
               *(curstat->GetProgressStatus()) += *(oldstat->GetProgressStatus());
         }
         PDB(kPacketizer,2)
            Info("GetNextPacket", "%s: asking new packetizer %p ... ", wrk->GetOrdinal(), fCurrent);
         elem = fCurrent->GetNextPacket(wrk, r);
      }
   }
   if (fCurrent) {
      // Save the packetizer
      TPair *pair = dynamic_cast<TPair *>(fAssignedPack->FindObject(wrk));
      if (pair) {
         pair->SetValue(fCurrent);
      } else {
         fAssignedPack->Add(wrk, fCurrent);
      }
      PDB(kPacketizer,2)
         Info("GetNextPacket", "assigned packetizer %p to %s (check: %p)",
                               fCurrent,  wrk->GetOrdinal(), fAssignedPack->GetValue(wrk));
   }

   // Check the total number of entries
   if (fProgressStatus->GetEntries() >= fTotalEntries) {
      if (fProgressStatus->GetEntries() > fTotalEntries)
         Error("GetNextPacket", "Processed too many entries!");
      HandleTimer(0);   // Send last timer message
      SafeDelete(fProgress);
   }

   // Done
   return elem;
}

//______________________________________________________________________________
TVirtualPacketizer *TPacketizerMulti::CreatePacketizer(TDSet *dset, TList *wrks,
                                                       Long64_t first, Long64_t num,
                                                       TList *input, TProofProgressStatus *st)
{
   // Create a packetizer for dataset 'dset'
   // Return null on failure.

   TVirtualPacketizer *packetizer = 0;

   // Check inputs
   if (!dset || !wrks || !input || !st) {
      Error("CreatePacketizer", "invalid inputs: dset:%p wrks:%p input:%p st:%p",
                                 dset, wrks, input, st);
      return packetizer;
   }

   // This is for data-driven runs
   if (dset->TestBit(TDSet::kEmpty)) {
      Error("CreatePacketizer", "dataset is empty: protocol error?");
      return packetizer;
   }

   TString packetizername;
   TList *listOfMissingFiles = 0;

   TMethodCall callEnv;
   TClass *cl;

   // Lookup - resolve the end-point urls to optmize the distribution.
   // The lookup was previously called in the packetizer's constructor.
   // A list for the missing files may already have been added to the
   // output list; otherwise, if needed it will be created inside
   if (!(listOfMissingFiles = (TList *) input->FindObject("MissingFiles"))) {
      // Create it
      listOfMissingFiles = new TList;
      // and add it to the input list; it will be later moved to the output list
      input->Add(listOfMissingFiles);
   }
   dset->Lookup(kTRUE, &listOfMissingFiles);

   if (!(dset->GetListOfElements()) ||
       !(dset->GetListOfElements()->GetSize())) {
      Error("CreatePacketizer", "no files from the data set were found - skipping");
      return packetizer;
   }

   if (TProof::GetParameter(input, "PROOF_Packetizer", packetizername) != 0) {
      // Using standard packetizer TPacketizer
      packetizername = "TPacketizer";
   } else {
      Info("CreatePacketizer", "using alternate packetizer: %s", packetizername.Data());
   }

   // Get linked to the related class
   cl = TClass::GetClass(packetizername);
   if (cl == 0) {
      Error("CreatePacketizer", "class '%s' not found", packetizername.Data());
      return packetizer;
   }

   // Init the constructor
   callEnv.InitWithPrototype(cl, cl->GetName(),"TDSet*,TList*,Long64_t,Long64_t,TList*,TProofProgressStatus*");
   if (!callEnv.IsValid()) {
      Error("CreatePacketizer", "cannot find correct constructor for '%s'", cl->GetName());
      return packetizer;
   }
   callEnv.ResetParam();
   callEnv.SetParam((Long_t) dset);
   callEnv.SetParam((Long_t) wrks);
   callEnv.SetParam((Long64_t) first);
   callEnv.SetParam((Long64_t) num);
   callEnv.SetParam((Long_t) input);
   callEnv.SetParam((Long_t) st);

   // We are going to test validity during the packetizer initialization
   dset->SetBit(TDSet::kValidityChecked);
   dset->ResetBit(TDSet::kSomeInvalid);

   // Get an instance of the packetizer
   Long_t ret = 0;
   callEnv.Execute(ret);
   if ((packetizer = (TVirtualPacketizer *)ret) == 0) {
      Error("CreatePacketizer", "cannot construct '%s'", cl->GetName());
      return packetizer;
   }

   if (!packetizer->IsValid()) {
      Error("CreatePacketizer",
            "instantiated packetizer object '%s' is invalid", cl->GetName());
      SafeDelete(packetizer);
   }

   // Add invalid elements to the list of missing elements
   TDSetElement *elem = 0;
   if (dset->TestBit(TDSet::kSomeInvalid)) {
      TIter nxe(dset->GetListOfElements());
      while ((elem = (TDSetElement *)nxe())) {
         if (!elem->GetValid()) {
            listOfMissingFiles->Add(elem->GetFileInfo(dset->GetType()));
            dset->Remove(elem, kFALSE);
         }
      }
      // The invalid elements have been removed
      dset->ResetBit(TDSet::kSomeInvalid);
   }

   // Done
   return packetizer;
}
 TPacketizerMulti.cxx:1
 TPacketizerMulti.cxx:2
 TPacketizerMulti.cxx:3
 TPacketizerMulti.cxx:4
 TPacketizerMulti.cxx:5
 TPacketizerMulti.cxx:6
 TPacketizerMulti.cxx:7
 TPacketizerMulti.cxx:8
 TPacketizerMulti.cxx:9
 TPacketizerMulti.cxx:10
 TPacketizerMulti.cxx:11
 TPacketizerMulti.cxx:12
 TPacketizerMulti.cxx:13
 TPacketizerMulti.cxx:14
 TPacketizerMulti.cxx:15
 TPacketizerMulti.cxx:16
 TPacketizerMulti.cxx:17
 TPacketizerMulti.cxx:18
 TPacketizerMulti.cxx:19
 TPacketizerMulti.cxx:20
 TPacketizerMulti.cxx:21
 TPacketizerMulti.cxx:22
 TPacketizerMulti.cxx:23
 TPacketizerMulti.cxx:24
 TPacketizerMulti.cxx:25
 TPacketizerMulti.cxx:26
 TPacketizerMulti.cxx:27
 TPacketizerMulti.cxx:28
 TPacketizerMulti.cxx:29
 TPacketizerMulti.cxx:30
 TPacketizerMulti.cxx:31
 TPacketizerMulti.cxx:32
 TPacketizerMulti.cxx:33
 TPacketizerMulti.cxx:34
 TPacketizerMulti.cxx:35
 TPacketizerMulti.cxx:36
 TPacketizerMulti.cxx:37
 TPacketizerMulti.cxx:38
 TPacketizerMulti.cxx:39
 TPacketizerMulti.cxx:40
 TPacketizerMulti.cxx:41
 TPacketizerMulti.cxx:42
 TPacketizerMulti.cxx:43
 TPacketizerMulti.cxx:44
 TPacketizerMulti.cxx:45
 TPacketizerMulti.cxx:46
 TPacketizerMulti.cxx:47
 TPacketizerMulti.cxx:48
 TPacketizerMulti.cxx:49
 TPacketizerMulti.cxx:50
 TPacketizerMulti.cxx:51
 TPacketizerMulti.cxx:52
 TPacketizerMulti.cxx:53
 TPacketizerMulti.cxx:54
 TPacketizerMulti.cxx:55
 TPacketizerMulti.cxx:56
 TPacketizerMulti.cxx:57
 TPacketizerMulti.cxx:58
 TPacketizerMulti.cxx:59
 TPacketizerMulti.cxx:60
 TPacketizerMulti.cxx:61
 TPacketizerMulti.cxx:62
 TPacketizerMulti.cxx:63
 TPacketizerMulti.cxx:64
 TPacketizerMulti.cxx:65
 TPacketizerMulti.cxx:66
 TPacketizerMulti.cxx:67
 TPacketizerMulti.cxx:68
 TPacketizerMulti.cxx:69
 TPacketizerMulti.cxx:70
 TPacketizerMulti.cxx:71
 TPacketizerMulti.cxx:72
 TPacketizerMulti.cxx:73
 TPacketizerMulti.cxx:74
 TPacketizerMulti.cxx:75
 TPacketizerMulti.cxx:76
 TPacketizerMulti.cxx:77
 TPacketizerMulti.cxx:78
 TPacketizerMulti.cxx:79
 TPacketizerMulti.cxx:80
 TPacketizerMulti.cxx:81
 TPacketizerMulti.cxx:82
 TPacketizerMulti.cxx:83
 TPacketizerMulti.cxx:84
 TPacketizerMulti.cxx:85
 TPacketizerMulti.cxx:86
 TPacketizerMulti.cxx:87
 TPacketizerMulti.cxx:88
 TPacketizerMulti.cxx:89
 TPacketizerMulti.cxx:90
 TPacketizerMulti.cxx:91
 TPacketizerMulti.cxx:92
 TPacketizerMulti.cxx:93
 TPacketizerMulti.cxx:94
 TPacketizerMulti.cxx:95
 TPacketizerMulti.cxx:96
 TPacketizerMulti.cxx:97
 TPacketizerMulti.cxx:98
 TPacketizerMulti.cxx:99
 TPacketizerMulti.cxx:100
 TPacketizerMulti.cxx:101
 TPacketizerMulti.cxx:102
 TPacketizerMulti.cxx:103
 TPacketizerMulti.cxx:104
 TPacketizerMulti.cxx:105
 TPacketizerMulti.cxx:106
 TPacketizerMulti.cxx:107
 TPacketizerMulti.cxx:108
 TPacketizerMulti.cxx:109
 TPacketizerMulti.cxx:110
 TPacketizerMulti.cxx:111
 TPacketizerMulti.cxx:112
 TPacketizerMulti.cxx:113
 TPacketizerMulti.cxx:114
 TPacketizerMulti.cxx:115
 TPacketizerMulti.cxx:116
 TPacketizerMulti.cxx:117
 TPacketizerMulti.cxx:118
 TPacketizerMulti.cxx:119
 TPacketizerMulti.cxx:120
 TPacketizerMulti.cxx:121
 TPacketizerMulti.cxx:122
 TPacketizerMulti.cxx:123
 TPacketizerMulti.cxx:124
 TPacketizerMulti.cxx:125
 TPacketizerMulti.cxx:126
 TPacketizerMulti.cxx:127
 TPacketizerMulti.cxx:128
 TPacketizerMulti.cxx:129
 TPacketizerMulti.cxx:130
 TPacketizerMulti.cxx:131
 TPacketizerMulti.cxx:132
 TPacketizerMulti.cxx:133
 TPacketizerMulti.cxx:134
 TPacketizerMulti.cxx:135
 TPacketizerMulti.cxx:136
 TPacketizerMulti.cxx:137
 TPacketizerMulti.cxx:138
 TPacketizerMulti.cxx:139
 TPacketizerMulti.cxx:140
 TPacketizerMulti.cxx:141
 TPacketizerMulti.cxx:142
 TPacketizerMulti.cxx:143
 TPacketizerMulti.cxx:144
 TPacketizerMulti.cxx:145
 TPacketizerMulti.cxx:146
 TPacketizerMulti.cxx:147
 TPacketizerMulti.cxx:148
 TPacketizerMulti.cxx:149
 TPacketizerMulti.cxx:150
 TPacketizerMulti.cxx:151
 TPacketizerMulti.cxx:152
 TPacketizerMulti.cxx:153
 TPacketizerMulti.cxx:154
 TPacketizerMulti.cxx:155
 TPacketizerMulti.cxx:156
 TPacketizerMulti.cxx:157
 TPacketizerMulti.cxx:158
 TPacketizerMulti.cxx:159
 TPacketizerMulti.cxx:160
 TPacketizerMulti.cxx:161
 TPacketizerMulti.cxx:162
 TPacketizerMulti.cxx:163
 TPacketizerMulti.cxx:164
 TPacketizerMulti.cxx:165
 TPacketizerMulti.cxx:166
 TPacketizerMulti.cxx:167
 TPacketizerMulti.cxx:168
 TPacketizerMulti.cxx:169
 TPacketizerMulti.cxx:170
 TPacketizerMulti.cxx:171
 TPacketizerMulti.cxx:172
 TPacketizerMulti.cxx:173
 TPacketizerMulti.cxx:174
 TPacketizerMulti.cxx:175
 TPacketizerMulti.cxx:176
 TPacketizerMulti.cxx:177
 TPacketizerMulti.cxx:178
 TPacketizerMulti.cxx:179
 TPacketizerMulti.cxx:180
 TPacketizerMulti.cxx:181
 TPacketizerMulti.cxx:182
 TPacketizerMulti.cxx:183
 TPacketizerMulti.cxx:184
 TPacketizerMulti.cxx:185
 TPacketizerMulti.cxx:186
 TPacketizerMulti.cxx:187
 TPacketizerMulti.cxx:188
 TPacketizerMulti.cxx:189
 TPacketizerMulti.cxx:190
 TPacketizerMulti.cxx:191
 TPacketizerMulti.cxx:192
 TPacketizerMulti.cxx:193
 TPacketizerMulti.cxx:194
 TPacketizerMulti.cxx:195
 TPacketizerMulti.cxx:196
 TPacketizerMulti.cxx:197
 TPacketizerMulti.cxx:198
 TPacketizerMulti.cxx:199
 TPacketizerMulti.cxx:200
 TPacketizerMulti.cxx:201
 TPacketizerMulti.cxx:202
 TPacketizerMulti.cxx:203
 TPacketizerMulti.cxx:204
 TPacketizerMulti.cxx:205
 TPacketizerMulti.cxx:206
 TPacketizerMulti.cxx:207
 TPacketizerMulti.cxx:208
 TPacketizerMulti.cxx:209
 TPacketizerMulti.cxx:210
 TPacketizerMulti.cxx:211
 TPacketizerMulti.cxx:212
 TPacketizerMulti.cxx:213
 TPacketizerMulti.cxx:214
 TPacketizerMulti.cxx:215
 TPacketizerMulti.cxx:216
 TPacketizerMulti.cxx:217
 TPacketizerMulti.cxx:218
 TPacketizerMulti.cxx:219
 TPacketizerMulti.cxx:220
 TPacketizerMulti.cxx:221
 TPacketizerMulti.cxx:222
 TPacketizerMulti.cxx:223
 TPacketizerMulti.cxx:224
 TPacketizerMulti.cxx:225
 TPacketizerMulti.cxx:226
 TPacketizerMulti.cxx:227
 TPacketizerMulti.cxx:228
 TPacketizerMulti.cxx:229
 TPacketizerMulti.cxx:230
 TPacketizerMulti.cxx:231
 TPacketizerMulti.cxx:232
 TPacketizerMulti.cxx:233
 TPacketizerMulti.cxx:234
 TPacketizerMulti.cxx:235
 TPacketizerMulti.cxx:236
 TPacketizerMulti.cxx:237
 TPacketizerMulti.cxx:238
 TPacketizerMulti.cxx:239
 TPacketizerMulti.cxx:240
 TPacketizerMulti.cxx:241
 TPacketizerMulti.cxx:242
 TPacketizerMulti.cxx:243
 TPacketizerMulti.cxx:244
 TPacketizerMulti.cxx:245
 TPacketizerMulti.cxx:246
 TPacketizerMulti.cxx:247
 TPacketizerMulti.cxx:248
 TPacketizerMulti.cxx:249
 TPacketizerMulti.cxx:250
 TPacketizerMulti.cxx:251
 TPacketizerMulti.cxx:252
 TPacketizerMulti.cxx:253
 TPacketizerMulti.cxx:254
 TPacketizerMulti.cxx:255
 TPacketizerMulti.cxx:256
 TPacketizerMulti.cxx:257
 TPacketizerMulti.cxx:258
 TPacketizerMulti.cxx:259
 TPacketizerMulti.cxx:260
 TPacketizerMulti.cxx:261
 TPacketizerMulti.cxx:262
 TPacketizerMulti.cxx:263
 TPacketizerMulti.cxx:264
 TPacketizerMulti.cxx:265
 TPacketizerMulti.cxx:266
 TPacketizerMulti.cxx:267
 TPacketizerMulti.cxx:268
 TPacketizerMulti.cxx:269
 TPacketizerMulti.cxx:270
 TPacketizerMulti.cxx:271
 TPacketizerMulti.cxx:272
 TPacketizerMulti.cxx:273
 TPacketizerMulti.cxx:274
 TPacketizerMulti.cxx:275
 TPacketizerMulti.cxx:276
 TPacketizerMulti.cxx:277
 TPacketizerMulti.cxx:278
 TPacketizerMulti.cxx:279
 TPacketizerMulti.cxx:280
 TPacketizerMulti.cxx:281
 TPacketizerMulti.cxx:282
 TPacketizerMulti.cxx:283
 TPacketizerMulti.cxx:284
 TPacketizerMulti.cxx:285
 TPacketizerMulti.cxx:286
 TPacketizerMulti.cxx:287
 TPacketizerMulti.cxx:288
 TPacketizerMulti.cxx:289
 TPacketizerMulti.cxx:290
 TPacketizerMulti.cxx:291
 TPacketizerMulti.cxx:292
 TPacketizerMulti.cxx:293
 TPacketizerMulti.cxx:294
 TPacketizerMulti.cxx:295
 TPacketizerMulti.cxx:296
 TPacketizerMulti.cxx:297
 TPacketizerMulti.cxx:298
 TPacketizerMulti.cxx:299
 TPacketizerMulti.cxx:300
 TPacketizerMulti.cxx:301
 TPacketizerMulti.cxx:302
 TPacketizerMulti.cxx:303
 TPacketizerMulti.cxx:304
 TPacketizerMulti.cxx:305
 TPacketizerMulti.cxx:306
 TPacketizerMulti.cxx:307
 TPacketizerMulti.cxx:308
 TPacketizerMulti.cxx:309
 TPacketizerMulti.cxx:310
 TPacketizerMulti.cxx:311
 TPacketizerMulti.cxx:312
 TPacketizerMulti.cxx:313
 TPacketizerMulti.cxx:314
 TPacketizerMulti.cxx:315
 TPacketizerMulti.cxx:316
 TPacketizerMulti.cxx:317
 TPacketizerMulti.cxx:318
 TPacketizerMulti.cxx:319
 TPacketizerMulti.cxx:320
 TPacketizerMulti.cxx:321
 TPacketizerMulti.cxx:322
 TPacketizerMulti.cxx:323
 TPacketizerMulti.cxx:324
 TPacketizerMulti.cxx:325
 TPacketizerMulti.cxx:326
 TPacketizerMulti.cxx:327
 TPacketizerMulti.cxx:328
 TPacketizerMulti.cxx:329
 TPacketizerMulti.cxx:330
 TPacketizerMulti.cxx:331
 TPacketizerMulti.cxx:332
 TPacketizerMulti.cxx:333
 TPacketizerMulti.cxx:334
 TPacketizerMulti.cxx:335
 TPacketizerMulti.cxx:336
 TPacketizerMulti.cxx:337
 TPacketizerMulti.cxx:338
 TPacketizerMulti.cxx:339
 TPacketizerMulti.cxx:340
 TPacketizerMulti.cxx:341