Fork me on GitHub

Changeset 341014c in git for readers


Ignore:
Timestamp:
Feb 12, 2019, 9:29:17 PM (6 years ago)
Author:
Pavel Demin <pavel-demin@…>
Branches:
ImprovedOutputFile, Timing, llp, master
Children:
6455202
Parents:
45e58be
Message:

apply .clang-format to all .h, .cc and .cpp files

Location:
readers
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • readers/DelphesCMSFWLite.cpp

    r45e58be r341014c  
    1818
    1919#include <algorithm>
     20#include <iostream>
     21#include <memory>
     22#include <sstream>
    2023#include <stdexcept>
    21 #include <iostream>
    22 #include <sstream>
    23 #include <memory>
    2424
    2525#include <map>
    2626#include <vector>
    2727
    28 #include <stdlib.h>
    2928#include <signal.h>
    3029#include <stdio.h>
    31 
     30#include <stdlib.h>
     31
     32#include "TApplication.h"
    3233#include "TROOT.h"
    33 #include "TApplication.h"
    34 
     34
     35#include "TDatabasePDG.h"
    3536#include "TFile.h"
     37#include "TLorentzVector.h"
    3638#include "TObjArray.h"
     39#include "TParticlePDG.h"
    3740#include "TStopwatch.h"
    38 #include "TDatabasePDG.h"
    39 #include "TParticlePDG.h"
    40 #include "TLorentzVector.h"
    41 
    42 #include "modules/Delphes.h"
    43 #include "classes/DelphesStream.h"
     41
    4442#include "classes/DelphesClasses.h"
    4543#include "classes/DelphesFactory.h"
    46 
     44#include "classes/DelphesStream.h"
     45#include "modules/Delphes.h"
     46
     47#include "ExRootAnalysis/ExRootProgressBar.h"
     48#include "ExRootAnalysis/ExRootTreeBranch.h"
    4749#include "ExRootAnalysis/ExRootTreeWriter.h"
    48 #include "ExRootAnalysis/ExRootTreeBranch.h"
    49 #include "ExRootAnalysis/ExRootProgressBar.h"
    50 
    51 #include "FWCore/FWLite/interface/FWLiteEnabler.h"
     50
    5251#include "DataFormats/FWLite/interface/Event.h"
    5352#include "DataFormats/FWLite/interface/Handle.h"
    5453#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
    5554#include "DataFormats/PatCandidates/interface/PackedGenParticle.h"
     55#include "FWCore/FWLite/interface/FWLiteEnabler.h"
     56#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
    5657#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
    57 #include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
    5858#include "SimDataFormats/GeneratorProducts/interface/LHEEventProduct.h"
    5959#include "SimDataFormats/GeneratorProducts/interface/WeightsInfo.h"
    … …  
    6969{
    7070
    71   fwlite::Handle< GenEventInfoProduct > handleGenEventInfo;
    72   fwlite::Handle< LHEEventProduct > handleLHEEvent;
    73   fwlite::Handle< vector< reco::GenParticle > > handleParticle;
    74   fwlite::Handle< vector< pat::PackedGenParticle > > handlePackedParticle;
    75 
    76   vector< reco::GenParticle >::const_iterator itParticle;
    77   vector< pat::PackedGenParticle >::const_iterator itPackedParticle;
    78 
    79   vector< const reco::Candidate * > vectorCandidate;
    80   vector< const reco::Candidate * >::iterator itCandidate;
     71  fwlite::Handle<GenEventInfoProduct> handleGenEventInfo;
     72  fwlite::Handle<LHEEventProduct> handleLHEEvent;
     73  fwlite::Handle<vector<reco::GenParticle>> handleParticle;
     74  fwlite::Handle<vector<pat::PackedGenParticle>> handlePackedParticle;
     75
     76  vector<reco::GenParticle>::const_iterator itParticle;
     77  vector<pat::PackedGenParticle>::const_iterator itPackedParticle;
     78
     79  vector<const reco::Candidate *> vectorCandidate;
     80  vector<const reco::Candidate *>::iterator itCandidate;
    8181
    8282  handleGenEventInfo.getByLabel(event, "generator");
    … …  
    9999    handleParticle.getByLabel(event, "genParticles");
    100100  }
    101   else if(!((handlePackedParticle.getBranchNameFor(event, "packedGenParticles")).empty()) && !((handleParticle.getBranchNameFor(event,"prunedGenParticles")).empty()))
     101  else if(!((handlePackedParticle.getBranchNameFor(event, "packedGenParticles")).empty()) && !((handleParticle.getBranchNameFor(event, "prunedGenParticles")).empty()))
    102102  {
    103103    handleParticle.getByLabel(event, "prunedGenParticles");
    … …  
    106106  else
    107107  {
    108     std::cout<<"Wrong GenParticle Label! Please, check the input file."<<std::endl;
     108    std::cout << "Wrong GenParticle Label! Please, check the input file." << std::endl;
    109109    exit(-1);
    110110  }
    111111
    112112  Bool_t foundLHE = !((handleLHEEvent.getBranchNameFor(event, "source")).empty()) || !((handleLHEEvent.getBranchNameFor(event, "externalLHEProducer")).empty());
    113   Bool_t isMiniAOD = !((handlePackedParticle.getBranchNameFor(event, "packedGenParticles")).empty()) && ((handleParticle.getBranchNameFor(event, "genParticles")).empty()) ;
     113  Bool_t isMiniAOD = !((handlePackedParticle.getBranchNameFor(event, "packedGenParticles")).empty()) && ((handleParticle.getBranchNameFor(event, "genParticles")).empty());
    114114
    115115  HepMCEvent *element;
    … …  
    148148  if(foundLHE)
    149149  {
    150     const vector< gen::WeightsInfo > &vectorWeightsInfo = handleLHEEvent->weights();
    151     vector< gen::WeightsInfo >::const_iterator itWeightsInfo;
     150    const vector<gen::WeightsInfo> &vectorWeightsInfo = handleLHEEvent->weights();
     151    vector<gen::WeightsInfo>::const_iterator itWeightsInfo;
    152152
    153153    for(itWeightsInfo = vectorWeightsInfo.begin(); itWeightsInfo != vectorWeightsInfo.end(); ++itWeightsInfo)
    … …  
    173173    status = particle.status();
    174174    if(isMiniAOD && particle.status() == 1) continue;
    175     px = particle.px(); py = particle.py(); pz = particle.pz(); e = particle.energy(); mass = particle.mass();
    176     x = particle.vx(); y = particle.vy(); z = particle.vz();
     175    px = particle.px();
     176    py = particle.py();
     177    pz = particle.pz();
     178    e = particle.energy();
     179    mass = particle.mass();
     180    x = particle.vx();
     181    y = particle.vy();
     182    z = particle.vz();
    177183
    178184    candidate = factory->NewCandidate();
    … …  
    196202
    197203    pdgParticle = pdg->GetParticle(pid);
    198     candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
     204    candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge() / 3.0) : -999;
    199205    candidate->Mass = mass;
    200206
    201207    candidate->Momentum.SetPxPyPzE(px, py, pz, e);
    202208
    203     candidate->Position.SetXYZT(x*10.0, y*10.0, z*10.0, 0.0);
     209    candidate->Position.SetXYZT(x * 10.0, y * 10.0, z * 10.0, 0.0);
    204210
    205211    allParticleOutputArray->Add(candidate);
    … …  
    232238    pid = particle.pdgId();
    233239    status = particle.status();
    234     px = particle.px(); py = particle.py(); pz = particle.pz(); e = particle.energy(); mass = particle.mass();
    235     x = particle.vx(); y = particle.vy(); z = particle.vz();
     240    px = particle.px();
     241    py = particle.py();
     242    pz = particle.pz();
     243    e = particle.energy();
     244    mass = particle.mass();
     245    x = particle.vx();
     246    y = particle.vy();
     247    z = particle.vz();
    236248
    237249    candidate = factory->NewCandidate();
    … …  
    255267
    256268    pdgParticle = pdg->GetParticle(pid);
    257     candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
     269    candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge() / 3.0) : -999;
    258270    candidate->Mass = mass;
    259271
    260272    candidate->Momentum.SetPxPyPzE(px, py, pz, e);
    261273
    262     candidate->Position.SetXYZT(x*10.0, y*10.0, z*10.0, 0.0);
     274    candidate->Position.SetXYZT(x * 10.0, y * 10.0, z * 10.0, 0.0);
    263275
    264276    allParticleOutputArray->Add(candidate);
    … …  
    303315  if(argc < 4)
    304316  {
    305     cout << " Usage: " << appName << " config_file" << " output_file" << " input_file(s)" << endl;
     317    cout << " Usage: " << appName << " config_file"
     318         << " output_file"
     319         << " input_file(s)" << endl;
    306320    cout << " config_file - configuration file in Tcl format," << endl;
    307321    cout << " output_file - output file in ROOT format," << endl;

  • readers/DelphesHepMC.cpp

    r45e58be r341014c  
    1717 */
    1818
    19 #include <stdexcept>
    2019#include <iostream>
    2120#include <sstream>
     21#include <stdexcept>
    2222
    2323#include <signal.h>
    2424
     25#include "TApplication.h"
    2526#include "TROOT.h"
    26 #include "TApplication.h"
    27 
     27
     28#include "TDatabasePDG.h"
    2829#include "TFile.h"
     30#include "TLorentzVector.h"
    2931#include "TObjArray.h"
     32#include "TParticlePDG.h"
    3033#include "TStopwatch.h"
    31 #include "TDatabasePDG.h"
    32 #include "TParticlePDG.h"
    33 #include "TLorentzVector.h"
    34 
    35 #include "modules/Delphes.h"
     34
    3635#include "classes/DelphesClasses.h"
    3736#include "classes/DelphesFactory.h"
    3837#include "classes/DelphesHepMCReader.h"
    39 
     38#include "modules/Delphes.h"
     39
     40#include "ExRootAnalysis/ExRootProgressBar.h"
     41#include "ExRootAnalysis/ExRootTreeBranch.h"
    4042#include "ExRootAnalysis/ExRootTreeWriter.h"
    41 #include "ExRootAnalysis/ExRootTreeBranch.h"
    42 #include "ExRootAnalysis/ExRootProgressBar.h"
    4343
    4444using namespace std;
    … …  
    7474  if(argc < 3)
    7575  {
    76     cout << " Usage: " << appName << " config_file" << " output_file" << " [input_file(s)]" << endl;
     76    cout << " Usage: " << appName << " config_file"
     77         << " output_file"
     78         << " [input_file(s)]" << endl;
    7779    cout << " config_file - configuration file in Tcl format," << endl;
    7880    cout << " output_file - output file in ROOT format," << endl;
    … …  
    178180      reader->Clear();
    179181      readStopWatch.Start();
    180       while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) &&
    181         reader->ReadBlock(factory, allParticleOutputArray,
    182         stableParticleOutputArray, partonOutputArray) && !interrupted)
     182      while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) && reader->ReadBlock(factory, allParticleOutputArray, stableParticleOutputArray, partonOutputArray) && !interrupted)
    183183      {
    184184        if(reader->EventReady())
    … …  
    217217
    218218      ++i;
    219     }
    220     while(i < argc);
     219    } while(i < argc);
    221220
    222221    modularDelphes->FinishTask();

  • readers/DelphesLHEF.cpp

    r45e58be r341014c  
    1717 */
    1818
    19 #include <stdexcept>
    2019#include <iostream>
    2120#include <sstream>
     21#include <stdexcept>
    2222
    2323#include <signal.h>
    2424
     25#include "TApplication.h"
    2526#include "TROOT.h"
    26 #include "TApplication.h"
    27 
     27
     28#include "TDatabasePDG.h"
    2829#include "TFile.h"
     30#include "TLorentzVector.h"
    2931#include "TObjArray.h"
     32#include "TParticlePDG.h"
    3033#include "TStopwatch.h"
    31 #include "TDatabasePDG.h"
    32 #include "TParticlePDG.h"
    33 #include "TLorentzVector.h"
    34 
    35 #include "modules/Delphes.h"
     34
    3635#include "classes/DelphesClasses.h"
    3736#include "classes/DelphesFactory.h"
    3837#include "classes/DelphesLHEFReader.h"
    39 
     38#include "modules/Delphes.h"
     39
     40#include "ExRootAnalysis/ExRootProgressBar.h"
     41#include "ExRootAnalysis/ExRootTreeBranch.h"
    4042#include "ExRootAnalysis/ExRootTreeWriter.h"
    41 #include "ExRootAnalysis/ExRootTreeBranch.h"
    42 #include "ExRootAnalysis/ExRootProgressBar.h"
    4343
    4444using namespace std;
    … …  
    7474  if(argc < 3)
    7575  {
    76     cout << " Usage: " << appName << " config_file" << " output_file" << " [input_file(s)]" << endl;
     76    cout << " Usage: " << appName << " config_file"
     77         << " output_file"
     78         << " [input_file(s)]" << endl;
    7779    cout << " config_file - configuration file in Tcl format," << endl;
    7880    cout << " output_file - output file in ROOT format," << endl;
    … …  
    178180      reader->Clear();
    179181      readStopWatch.Start();
    180       while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) &&
    181         reader->ReadBlock(factory, allParticleOutputArray,
    182         stableParticleOutputArray, partonOutputArray) && !interrupted)
     182      while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) && reader->ReadBlock(factory, allParticleOutputArray, stableParticleOutputArray, partonOutputArray) && !interrupted)
    183183      {
    184184        if(reader->EventReady())
    … …  
    218218
    219219      ++i;
    220     }
    221     while(i < argc);
     220    } while(i < argc);
    222221
    223222    modularDelphes->FinishTask();

  • readers/DelphesProIO.cpp

    r45e58be r341014c  
    1818 */
    1919
     20#include <iostream>
     21#include <memory>
     22#include <sstream>
    2023#include <stdexcept>
    21 #include <iostream>
    22 #include <sstream>
    23 #include <memory>
    2424
    2525#include <map>
    2626
    27 #include <stdlib.h>
    2827#include <signal.h>
    2928#include <stdio.h>
    30 
     29#include <stdlib.h>
     30
     31#include "TApplication.h"
    3132#include "TROOT.h"
    32 #include "TApplication.h"
    33 
     33
     34#include "TDatabasePDG.h"
    3435#include "TFile.h"
     36#include "TLorentzVector.h"
    3537#include "TObjArray.h"
     38#include "TParticlePDG.h"
    3639#include "TStopwatch.h"
    37 #include "TDatabasePDG.h"
    38 #include "TParticlePDG.h"
    39 #include "TLorentzVector.h"
    40 
    41 #include "modules/Delphes.h"
    42 #include "classes/DelphesStream.h"
     40
    4341#include "classes/DelphesClasses.h"
    4442#include "classes/DelphesFactory.h"
    45 
     43#include "classes/DelphesStream.h"
     44#include "modules/Delphes.h"
     45
     46#include "ExRootAnalysis/ExRootProgressBar.h"
     47#include "ExRootAnalysis/ExRootTreeBranch.h"
    4648#include "ExRootAnalysis/ExRootTreeWriter.h"
    47 #include "ExRootAnalysis/ExRootTreeBranch.h"
    48 #include "ExRootAnalysis/ExRootProgressBar.h"
    49 
    50 #include <proio/reader.h>
     49
    5150#include <proio/event.h>
    5251#include <proio/model/mc.pb.h>
    53 namespace model=proio::model::mc;
    54 
     52#include <proio/reader.h>
     53namespace model = proio::model::mc;
    5554
    5655using namespace std;
    … …  
    5958// This method dynamically checks the message type (varint or not) depending on
    6059// non-zero value of units momentumUnit and positionUnit.
    61 void ConvertInput(proio::Event *event, double momentumUnit, double positionUnit, 
     60void ConvertInput(proio::Event *event, double momentumUnit, double positionUnit,
    6261  ExRootTreeBranch *branch, DelphesFactory *factory,
    6362  TObjArray *allParticleOutputArray, TObjArray *stableParticleOutputArray,
    … …  
    8079  element = static_cast<HepMCEvent *>(branch->NewEntry());
    8180
    82  int nID=0;
    83  double weight=0;
    84  int process_id=0;
    85  auto mcentries = event->TaggedEntries("MCParameters");
    86  for (uint64_t mcentryID : mcentries) {
    87    auto mcpar = dynamic_cast<proio::model::mc::MCParameters *>(event->GetEntry(mcentryID));
    88    nID=mcpar->number();
    89    weight=mcpar->weight();
    90    process_id=mcpar->processid();
    91    break; // consider only most generic from 1st entry
    92  };
     81  int nID = 0;
     82  double weight = 0;
     83  int process_id = 0;
     84  auto mcentries = event->TaggedEntries("MCParameters");
     85  for(uint64_t mcentryID : mcentries)
     86  {
     87    auto mcpar = dynamic_cast<proio::model::mc::MCParameters *>(event->GetEntry(mcentryID));
     88    nID = mcpar->number();
     89    weight = mcpar->weight();
     90    process_id = mcpar->processid();
     91    break; // consider only most generic from 1st entry
     92  };
    9393
    9494  element->Number = nID;
    95   element->ProcessID =process_id;
     95  element->ProcessID = process_id;
    9696  element->Weight = weight;
    9797
    98 /*
     98  /*
    9999  // Pythia8 specific
    100100  element->MPI = mutableEvent->mpi();
    … …  
    114114  element->ProcTime = procStopWatch->RealTime();
    115115
    116 
    117 
    118  if ( momentumUnit >0 && positionUnit>0) {
    119 
    120 
    121   auto entries = event->TaggedEntries("VarintPackedParticles");
    122 
    123   for (uint64_t entryID : entries) {
    124 
    125     auto mutableParticles = dynamic_cast<model::VarintPackedParticles *>(event->GetEntry(entryID));
    126 
    127     for(int i = 0; i < mutableParticles->pdg_size(); ++i)
    128    {
    129     pid = mutableParticles->pdg(i);
    130     status = mutableParticles->status(i);
    131     px = mutableParticles->px(i)/momentumUnit;
    132     py = mutableParticles->py(i)/momentumUnit;
    133     pz = mutableParticles->pz(i)/momentumUnit;
    134     mass = mutableParticles->mass(i)/momentumUnit;
    135     x = mutableParticles->x(i)/positionUnit;
    136     y = mutableParticles->y(i)/positionUnit;
    137     z = mutableParticles->z(i)/positionUnit;
    138     t = mutableParticles->t(i)/positionUnit;
    139    
    140     candidate = factory->NewCandidate();
    141     candidate->PID = pid;
    142     pdgCode = TMath::Abs(candidate->PID);
    143     candidate->Status = status;
    144     candidate->M1 = mutableParticles->parent1(i);
    145     candidate->M2 = mutableParticles->parent2(i);
    146     candidate->D1 = mutableParticles->child1(i);
    147     candidate->D2 = mutableParticles->child2(i);
    148     pdgParticle = pdg->GetParticle(pid);
    149     candidate->Charge = mutableParticles->charge(i)/3.0;
    150     //candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
    151     candidate->Mass = mass;
    152     candidate->Momentum.SetXYZM(px, py, pz, mass);
    153     candidate->Position.SetXYZT(x, y, z, t);
    154     allParticleOutputArray->Add(candidate);
    155     if(!pdgParticle) continue;
    156 
    157     if(status == 1)
     116  if(momentumUnit > 0 && positionUnit > 0)
     117  {
     118
     119    auto entries = event->TaggedEntries("VarintPackedParticles");
     120
     121    for(uint64_t entryID : entries)
    158122    {
    159       stableParticleOutputArray->Add(candidate);
    160     }
    161     else if(pdgCode <= 5 || pdgCode == 21 || pdgCode == 15)
    162     {
    163       partonOutputArray->Add(candidate);
     123
     124      auto mutableParticles = dynamic_cast<model::VarintPackedParticles *>(event->GetEntry(entryID));
     125
     126      for(int i = 0; i < mutableParticles->pdg_size(); ++i)
     127      {
     128        pid = mutableParticles->pdg(i);
     129        status = mutableParticles->status(i);
     130        px = mutableParticles->px(i) / momentumUnit;
     131        py = mutableParticles->py(i) / momentumUnit;
     132        pz = mutableParticles->pz(i) / momentumUnit;
     133        mass = mutableParticles->mass(i) / momentumUnit;
     134        x = mutableParticles->x(i) / positionUnit;
     135        y = mutableParticles->y(i) / positionUnit;
     136        z = mutableParticles->z(i) / positionUnit;
     137        t = mutableParticles->t(i) / positionUnit;
     138
     139        candidate = factory->NewCandidate();
     140        candidate->PID = pid;
     141        pdgCode = TMath::Abs(candidate->PID);
     142        candidate->Status = status;
     143        candidate->M1 = mutableParticles->parent1(i);
     144        candidate->M2 = mutableParticles->parent2(i);
     145        candidate->D1 = mutableParticles->child1(i);
     146        candidate->D2 = mutableParticles->child2(i);
     147        pdgParticle = pdg->GetParticle(pid);
     148        candidate->Charge = mutableParticles->charge(i) / 3.0;
     149        //candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
     150        candidate->Mass = mass;
     151        candidate->Momentum.SetXYZM(px, py, pz, mass);
     152        candidate->Position.SetXYZT(x, y, z, t);
     153        allParticleOutputArray->Add(candidate);
     154        if(!pdgParticle) continue;
     155
     156        if(status == 1)
     157        {
     158          stableParticleOutputArray->Add(candidate);
     159        }
     160        else if(pdgCode <= 5 || pdgCode == 21 || pdgCode == 15)
     161        {
     162          partonOutputArray->Add(candidate);
     163        }
     164      }
    164165    }
    165166  }
    166 
    167   }
    168 
    169  } else {
    170 
    171 
    172  auto entries = event->TaggedEntries("Particle");
    173 
    174  for (uint64_t entryID : entries) {
    175     auto part = dynamic_cast<model::Particle *>(event->GetEntry(entryID));
    176     pid = part->pdg();
    177     status = part->status();
    178     model::XYZF pvector=part->p();
    179     px=pvector.x();
    180     py=pvector.y();
    181     pz=pvector.z();
    182     mass = part->mass();
    183     auto v =part->vertex();
    184     x=v.x();
    185     y=v.y();
    186     z=v.z();
    187     t=v.t();
    188 
    189     candidate = factory->NewCandidate();
    190     candidate->PID = pid;
    191     pdgCode = TMath::Abs(candidate->PID);
    192     candidate->Status = status;
    193 
    194     int M1=0;
    195     int M2=0;
    196     for (int k1=0; k1<part->parent_size(); k1++){
    197        if (k1==0) {
    198                    auto mother = dynamic_cast<model::Particle *>(event->GetEntry(part->parent(0)));
    199                    M1=mother->barcode();
    200        }
    201        if (k1==1) {
    202                    auto mother = dynamic_cast<model::Particle *>(event->GetEntry(part->parent(1)));
    203                    M2=mother->barcode();
    204        }
     167  else
     168  {
     169
     170    auto entries = event->TaggedEntries("Particle");
     171
     172    for(uint64_t entryID : entries)
     173    {
     174      auto part = dynamic_cast<model::Particle *>(event->GetEntry(entryID));
     175      pid = part->pdg();
     176      status = part->status();
     177      model::XYZF pvector = part->p();
     178      px = pvector.x();
     179      py = pvector.y();
     180      pz = pvector.z();
     181      mass = part->mass();
     182      auto v = part->vertex();
     183      x = v.x();
     184      y = v.y();
     185      z = v.z();
     186      t = v.t();
     187
     188      candidate = factory->NewCandidate();
     189      candidate->PID = pid;
     190      pdgCode = TMath::Abs(candidate->PID);
     191      candidate->Status = status;
     192
     193      int M1 = 0;
     194      int M2 = 0;
     195      for(int k1 = 0; k1 < part->parent_size(); k1++)
     196      {
     197        if(k1 == 0)
     198        {
     199          auto mother = dynamic_cast<model::Particle *>(event->GetEntry(part->parent(0)));
     200          M1 = mother->barcode();
     201        }
     202        if(k1 == 1)
     203        {
     204          auto mother = dynamic_cast<model::Particle *>(event->GetEntry(part->parent(1)));
     205          M2 = mother->barcode();
     206        }
     207      }
     208
     209      int D1 = 0;
     210      int D2 = 0;
     211      for(int k1 = 0; k1 < part->child_size(); k1++)
     212      {
     213        if(k1 == 0)
     214        {
     215          auto child = dynamic_cast<model::Particle *>(event->GetEntry(part->child(0)));
     216          D1 = child->barcode();
     217        }
     218
     219        if(k1 == 1)
     220        {
     221          auto child = dynamic_cast<model::Particle *>(event->GetEntry(part->child(1)));
     222          D2 = child->barcode();
     223        };
     224      }
     225
     226      candidate->M1 = M1;
     227      candidate->M2 = M2;
     228      candidate->D1 = D1;
     229      candidate->D2 = D2;
     230
     231      pdgParticle = pdg->GetParticle(pid);
     232      candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge() / 3.0) : -999;
     233      candidate->Mass = mass;
     234
     235      candidate->Momentum.SetXYZM(px, py, pz, mass);
     236
     237      candidate->Position.SetXYZT(x, y, z, t);
     238
     239      allParticleOutputArray->Add(candidate);
     240
     241      if(!pdgParticle) continue;
     242
     243      if(status == 1)
     244      {
     245        stableParticleOutputArray->Add(candidate);
     246      }
     247      else if(pdgCode <= 5 || pdgCode == 21 || pdgCode == 15)
     248      {
     249        partonOutputArray->Add(candidate);
     250      }
    205251    }
    206252
    207 
    208     int D1=0;
    209     int D2=0;
    210     for (int k1=0; k1<part->child_size(); k1++){
    211        if (k1==0) {
    212                    auto child = dynamic_cast<model::Particle *>(event->GetEntry(part->child(0)));
    213                    D1=child->barcode();
    214        }
    215 
    216       if (k1==1) {
    217                    auto child = dynamic_cast<model::Particle *>(event->GetEntry(part->child(1)));
    218                    D2=child->barcode();
    219          };
    220       }
    221 
    222 
    223     candidate->M1 = M1;
    224     candidate->M2 = M2;
    225     candidate->D1 = D1;
    226     candidate->D2 = D2;
    227 
    228     pdgParticle = pdg->GetParticle(pid);
    229     candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
    230     candidate->Mass = mass;
    231 
    232     candidate->Momentum.SetXYZM(px, py, pz, mass);
    233 
    234     candidate->Position.SetXYZT(x, y, z, t);
    235 
    236     allParticleOutputArray->Add(candidate);
    237 
    238     if(!pdgParticle) continue;
    239 
    240     if(status == 1)
    241     {
    242       stableParticleOutputArray->Add(candidate);
    243     }
    244     else if(pdgCode <= 5 || pdgCode == 21 || pdgCode == 15)
    245     {
    246       partonOutputArray->Add(candidate);
    247     }
    248 
    249   }
    250 
    251 
    252   } // end particle type
    253 
     253  } // end particle type
    254254}
    255255
    … …  
    283283  if(argc < 4)
    284284  {
    285     cout << " Usage: " << appName << " config_file" << " output_file" << " input_file(s)" << endl;
     285    cout << " Usage: " << appName << " config_file"
     286         << " output_file"
     287         << " input_file(s)" << endl;
    286288    cout << " config_file - configuration file in Tcl format," << endl;
    287289    cout << " output_file - output file in ROOT format," << endl;
    … …  
    330332      cout << "** INFO: Reading " << argv[i] << endl;
    331333
    332       inputFile=new proio::Reader( argv[i] );
     334      inputFile = new proio::Reader(argv[i]);
    333335
    334336      if(inputFile == NULL)
    … …  
    338340      }
    339341
    340 
    341 /*
     342      /*
    342343// this is slow method, but general
    343344      inputFile->SeekToStart();
    … …  
    350351*/
    351352
    352 
    353     auto event = new proio::Event();
    354 
    355 
    356    double varint_energy=0;
    357    double varint_length=0;
    358 
    359 
    360     auto max_n_events = std::numeric_limits<uint64_t>::max();
    361     auto nn = inputFile->Skip(max_n_events);
    362     cout << "** INFO: " << nn-1 << " events found in ProIO file" << endl;
    363     inputFile->SeekToStart();
    364     numberOfEvents = nn-1; // last event has only metadata (no particle record)
    365  
    366     if(numberOfEvents <= 0) continue;
    367 
    368     ExRootProgressBar progressBar(numberOfEvents - 1);
    369 
     353      auto event = new proio::Event();
     354
     355      double varint_energy = 0;
     356      double varint_length = 0;
     357
     358      auto max_n_events = std::numeric_limits<uint64_t>::max();
     359      auto nn = inputFile->Skip(max_n_events);
     360      cout << "** INFO: " << nn - 1 << " events found in ProIO file" << endl;
     361      inputFile->SeekToStart();
     362      numberOfEvents = nn - 1; // last event has only metadata (no particle record)
     363
     364      if(numberOfEvents <= 0) continue;
     365
     366      ExRootProgressBar progressBar(numberOfEvents - 1);
    370367
    371368      // Loop over all objects
    … …  
    376373      for(eventCounter = 0; eventCounter < numberOfEvents && !interrupted; ++eventCounter)
    377374      {
    378         inputFile->Next(event); 
     375        inputFile->Next(event);
    379376        if(event == 0) continue;
    380377
    381        // get metadata
    382        if (eventCounter == 0) {
    383        auto metadata = event->Metadata();
    384        std::cout << "** INFO: ProIO file metadata:" << std::endl;
    385        for (auto element : metadata) {
    386         string key=(string)element.first;
    387         string value=(string)(*element.second);
    388         std::cout << "** INFO:   " << key << " = " << value << std::endl;
    389         if (key=="info:varint_energy") varint_energy=std::stod(value);
    390         if (key=="info:varint_length") varint_length=std::stod(value);
    391         }
    392        }
    393 
     378        // get metadata
     379        if(eventCounter == 0)
     380        {
     381          auto metadata = event->Metadata();
     382          std::cout << "** INFO: ProIO file metadata:" << std::endl;
     383          for(auto element : metadata)
     384          {
     385            string key = (string)element.first;
     386            string value = (string)(*element.second);
     387            std::cout << "** INFO:   " << key << " = " << value << std::endl;
     388            if(key == "info:varint_energy") varint_energy = std::stod(value);
     389            if(key == "info:varint_length") varint_length = std::stod(value);
     390          }
     391        }
    394392
    395393        readStopWatch.Stop();
    … …  
    397395        procStopWatch.Start();
    398396
    399         ConvertInput(event, varint_energy, varint_length, 
     397        ConvertInput(event, varint_energy, varint_length,
    400398          branchEvent, factory,
    401399          allParticleOutputArray, stableParticleOutputArray,
    402400          partonOutputArray, &readStopWatch, &procStopWatch);
    403  
     401
    404402        modularDelphes->ProcessTask();
    405403        procStopWatch.Stop();
    … …  
    414412      }
    415413
    416 
    417414      progressBar.Update(eventCounter, eventCounter, kTRUE);
    418415      progressBar.Finish();
    … …  
    420417      delete inputFile;
    421418    }
    422 
    423419
    424420    modularDelphes->FinishTask();

  • readers/DelphesProMC.cpp

    r45e58be r341014c  
    1717 */
    1818
     19#include <iostream>
     20#include <memory>
     21#include <sstream>
    1922#include <stdexcept>
    20 #include <iostream>
    21 #include <sstream>
    22 #include <memory>
    2323
    2424#include <map>
    2525
    26 #include <stdlib.h>
    2726#include <signal.h>
    2827#include <stdio.h>
    29 
     28#include <stdlib.h>
     29
     30#include "TApplication.h"
    3031#include "TROOT.h"
    31 #include "TApplication.h"
    32 
     32
     33#include "TDatabasePDG.h"
    3334#include "TFile.h"
     35#include "TLorentzVector.h"
    3436#include "TObjArray.h"
     37#include "TParticlePDG.h"
    3538#include "TStopwatch.h"
    36 #include "TDatabasePDG.h"
    37 #include "TParticlePDG.h"
    38 #include "TLorentzVector.h"
    39 
    40 #include "modules/Delphes.h"
    41 #include "classes/DelphesStream.h"
     39
    4240#include "classes/DelphesClasses.h"
    4341#include "classes/DelphesFactory.h"
    44 
     42#include "classes/DelphesStream.h"
     43#include "modules/Delphes.h"
     44
     45#include "ExRootAnalysis/ExRootProgressBar.h"
     46#include "ExRootAnalysis/ExRootTreeBranch.h"
    4547#include "ExRootAnalysis/ExRootTreeWriter.h"
    46 #include "ExRootAnalysis/ExRootTreeBranch.h"
    47 #include "ExRootAnalysis/ExRootProgressBar.h"
    4848
    4949#include "ProMC.pb.h"
    … …  
    109109    status = mutableParticles->status(i);
    110110
    111     px = mutableParticles->px(i)/momentumUnit;
    112     py = mutableParticles->py(i)/momentumUnit;
    113     pz = mutableParticles->pz(i)/momentumUnit;
    114     mass = mutableParticles->mass(i)/momentumUnit;
    115     x = mutableParticles->x(i)/positionUnit;
    116     y = mutableParticles->y(i)/positionUnit;
    117     z = mutableParticles->z(i)/positionUnit;
    118     t = mutableParticles->t(i)/positionUnit;
     111    px = mutableParticles->px(i) / momentumUnit;
     112    py = mutableParticles->py(i) / momentumUnit;
     113    pz = mutableParticles->pz(i) / momentumUnit;
     114    mass = mutableParticles->mass(i) / momentumUnit;
     115    x = mutableParticles->x(i) / positionUnit;
     116    y = mutableParticles->y(i) / positionUnit;
     117    z = mutableParticles->z(i) / positionUnit;
     118    t = mutableParticles->t(i) / positionUnit;
    119119
    120120    candidate = factory->NewCandidate();
    … …  
    125125    candidate->Status = status;
    126126
    127     candidate->IsPU=0;
    128     if (mutableParticles->barcode(i)>0) candidate->IsPU=1; // pileup particle
     127    candidate->IsPU = 0;
     128    if(mutableParticles->barcode(i) > 0) candidate->IsPU = 1; // pileup particle
    129129
    130130    candidate->M1 = mutableParticles->mother1(i);
    … …  
    135135
    136136    pdgParticle = pdg->GetParticle(pid);
    137     candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
     137    candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge() / 3.0) : -999;
    138138    candidate->Mass = mass;
    139139
    … …  
    187187  if(argc < 4)
    188188  {
    189     cout << " Usage: " << appName << " config_file" << " output_file" << " input_file(s)" << endl;
     189    cout << " Usage: " << appName << " config_file"
     190         << " output_file"
     191         << " input_file(s)" << endl;
    190192    cout << " config_file - configuration file in Tcl format," << endl;
    191193    cout << " output_file - output file in ROOT format," << endl;
    … …  
    234236      cout << "** Reading " << argv[i] << endl;
    235237
    236       // use 64 bit 
     238      // use 64 bit
    237239      //inputFile = new ProMCBook(argv[i], "r", true);
    238240
    … …  
    244246      momentumUnit = static_cast<double>(header.momentumunit());
    245247      positionUnit = static_cast<double>(header.lengthunit());
    246 
    247 
    248248
    249249      if(inputFile == NULL)

  • readers/DelphesPythia8.cpp

    r45e58be r341014c  
    1717 */
    1818
    19 #include <stdexcept>
    2019#include <iostream>
    2120#include <sstream>
     21#include <stdexcept>
    2222#include <string>
    2323
    … …  
    2727#include "Pythia8Plugins/CombineMatchingInput.h"
    2828
     29#include "TApplication.h"
    2930#include "TROOT.h"
    30 #include "TApplication.h"
    31 
     31
     32#include "TDatabasePDG.h"
    3233#include "TFile.h"
     34#include "TLorentzVector.h"
    3335#include "TObjArray.h"
     36#include "TParticlePDG.h"
    3437#include "TStopwatch.h"
    35 #include "TDatabasePDG.h"
    36 #include "TParticlePDG.h"
    37 #include "TLorentzVector.h"
    38 
    39 #include "modules/Delphes.h"
     38
    4039#include "classes/DelphesClasses.h"
    4140#include "classes/DelphesFactory.h"
    4241#include "classes/DelphesLHEFReader.h"
    43 
     42#include "modules/Delphes.h"
     43
     44#include "ExRootAnalysis/ExRootProgressBar.h"
     45#include "ExRootAnalysis/ExRootTreeBranch.h"
    4446#include "ExRootAnalysis/ExRootTreeWriter.h"
    45 #include "ExRootAnalysis/ExRootTreeBranch.h"
    46 #include "ExRootAnalysis/ExRootProgressBar.h"
    4747
    4848using namespace std;
    … …  
    9898    pid = particle.id();
    9999    status = particle.statusHepMC();
    100     px = particle.px(); py = particle.py(); pz = particle.pz(); e = particle.e(); mass = particle.m();
    101     x = particle.xProd(); y = particle.yProd(); z = particle.zProd(); t = particle.tProd();
     100    px = particle.px();
     101    py = particle.py();
     102    pz = particle.pz();
     103    e = particle.e();
     104    mass = particle.m();
     105    x = particle.xProd();
     106    y = particle.yProd();
     107    z = particle.zProd();
     108    t = particle.tProd();
    102109
    103110    candidate = factory->NewCandidate();
    … …  
    115122
    116123    pdgParticle = pdg->GetParticle(pid);
    117     candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge()/3.0) : -999;
     124    candidate->Charge = pdgParticle ? Int_t(pdgParticle->Charge() / 3.0) : -999;
    118125    candidate->Mass = mass;
    119126
    … …  
    166173
    167174  // pMin = 0.1 GeV for single particles
    168   pp = pow(10, - 1.0 + (log10(pMax) + 1.0) * rndm.flat());
     175  pp = pow(10, -1.0 + (log10(pMax) + 1.0) * rndm.flat());
    169176  eta = (2.0 * rndm.flat() - 1.0) * etaMax;
    170177  phi = 2.0 * M_PI * rndm.flat();
    171178  mm = pdt.mSel(id);
    172   ee = Pythia8::sqrtpos(pp*pp + mm*mm);
     179  ee = Pythia8::sqrtpos(pp * pp + mm * mm);
    173180  pt = pp / cosh(eta);
    174181
    … …  
    193200  phi = 2.0 * M_PI * rndm.flat();
    194201  mm = pdt.mSel(id);
    195   ee = Pythia8::sqrtpos(pp*pp + mm*mm);
     202  ee = Pythia8::sqrtpos(pp * pp + mm * mm);
    196203  pt = pp / cosh(eta);
    197204
    198   if( (id == 4 || id == 5) && pt < 10.0) return;
     205  if((id == 4 || id == 5) && pt < 10.0) return;
    199206
    200207  if(id == 21)
    … …  
    238245  // for matching
    239246  Pythia8::CombineMatchingInput *combined = 0;
    240   Pythia8::UserHooks* matching = 0;
     247  Pythia8::UserHooks *matching = 0;
    241248
    242249  if(argc != 4)
    243250  {
    244     cout << " Usage: " << appName << " config_file" << " pythia_card" << " output_file" << endl;
     251    cout << " Usage: " << appName << " config_file"
     252         << " pythia_card"
     253         << " output_file" << endl;
    245254    cout << " config_file - configuration file in Tcl format," << endl;
    246255    cout << " pythia_card - Pythia8 configuration file," << endl;
    … …  
    293302    }
    294303    pythia->setUserHooksPtr(matching);
    295 
    296304
    297305    if(pythia == NULL)
    … …  
    348356    for(eventCounter = 0; eventCounter < numberOfEvents && !interrupted; ++eventCounter)
    349357    {
    350       while(reader && reader->ReadBlock(factory, allParticleOutputArrayLHEF,
    351         stableParticleOutputArrayLHEF, partonOutputArrayLHEF) && !reader->EventReady());
     358      while(reader && reader->ReadBlock(factory, allParticleOutputArrayLHEF, stableParticleOutputArrayLHEF, partonOutputArrayLHEF) && !reader->EventReady())
     359        ;
    352360
    353361      if(spareFlag1)

  • readers/DelphesROOT.cpp

    r45e58be r341014c  
    1818
    1919#include <algorithm>
     20#include <iostream>
     21#include <memory>
     22#include <sstream>
    2023#include <stdexcept>
    21 #include <iostream>
    22 #include <sstream>
    23 #include <memory>
    2424
    2525#include <map>
    2626#include <vector>
    2727
    28 #include <stdlib.h>
    2928#include <signal.h>
    3029#include <stdio.h>
    31 
     30#include <stdlib.h>
     31
     32#include "TApplication.h"
    3233#include "TROOT.h"
    33 #include "TApplication.h"
    34 
     34
     35#include "TClonesArray.h"
     36#include "TDatabasePDG.h"
    3537#include "TFile.h"
    36 #include "TClonesArray.h"
     38#include "TLorentzVector.h"
    3739#include "TObjArray.h"
     40#include "TParticlePDG.h"
    3841#include "TStopwatch.h"
    39 #include "TDatabasePDG.h"
    40 #include "TParticlePDG.h"
    41 #include "TLorentzVector.h"
    42 
    43 #include "modules/Delphes.h"
    44 #include "classes/DelphesStream.h"
     42
    4543#include "classes/DelphesClasses.h"
    4644#include "classes/DelphesFactory.h"
    47 
     45#include "classes/DelphesStream.h"
     46#include "modules/Delphes.h"
     47
     48#include "ExRootAnalysis/ExRootProgressBar.h"
     49#include "ExRootAnalysis/ExRootTreeBranch.h"
     50#include "ExRootAnalysis/ExRootTreeReader.h"
    4851#include "ExRootAnalysis/ExRootTreeWriter.h"
    49 #include "ExRootAnalysis/ExRootTreeReader.h"
    50 #include "ExRootAnalysis/ExRootTreeBranch.h"
    51 #include "ExRootAnalysis/ExRootProgressBar.h"
    52 
    53 
    5452
    5553using namespace std;
    5654
    5755//---------------------------------------------------------------------------
    58 
    5956
    6057//---------------------------------------------------------------------------
    … …  
    9491  if(argc < 4)
    9592  {
    96     cout << " Usage: " << appName << " config_file" << " output_file" << " input_file(s)" << endl;
     93    cout << " Usage: " << appName << " config_file"
     94         << " output_file"
     95         << " input_file(s)" << endl;
    9796    cout << " config_file - configuration file in Tcl format," << endl;
    9897    cout << " output_file - output file in ROOT format," << endl;
    … …  
    122121
    123122    branchEvent = treeWriter->NewBranch("Event", HepMCEvent::Class());
    124    
     123
    125124    confReader = new ExRootConfReader;
    126125    confReader->ReadFile(argv[1]);
    … …  
    129128    modularDelphes->SetConfReader(confReader);
    130129    modularDelphes->SetTreeWriter(treeWriter);
    131    
     130
    132131    TChain *chain = new TChain("Delphes");
    133    
     132
    134133    factory = modularDelphes->GetFactory();
    135134    allParticleOutputArray = modularDelphes->ExportArray("allParticles");
    … …  
    145144      chain->Add(argv[i]);
    146145      ExRootTreeReader *treeReader = new ExRootTreeReader(chain);
    147      
     146
    148147      inputFile = TFile::Open(argv[i]);
    149148
    … …  
    153152        throw runtime_error(message.str());
    154153      }
    155      
     154
    156155      numberOfEvents = treeReader->GetEntries();
    157       TClonesArray *branchParticle   = treeReader->UseBranch("Particle");
     156      TClonesArray *branchParticle = treeReader->UseBranch("Particle");
    158157      TClonesArray *branchHepMCEvent = treeReader->UseBranch("Event");
    159      
     158
    160159      if(numberOfEvents <= 0) continue;
    161160
    … …  
    169168      for(Int_t entry = 0; entry < numberOfEvents && !interrupted; ++entry)
    170169      {
    171    
     170
    172171        treeReader->ReadEntry(entry);
    173172
    174         // -- TBC need also to include event weights -- 
    175        
    176         eve = (HepMCEvent*) branchHepMCEvent->At(0);
     173        // -- TBC need also to include event weights --
     174
     175        eve = (HepMCEvent *)branchHepMCEvent->At(0);
    177176        element = static_cast<HepMCEvent *>(branchEvent->NewEntry());
    178        
     177
    179178        element->Number = eventCounter;
    180179
    … …  
    197196        element->ProcTime = eve->ProcTime;
    198197
    199         for(Int_t j=0; j < branchParticle->GetEntriesFast(); j++)
    200         {     
    201          
    202           gen = (GenParticle*) branchParticle->At(j);     
     198        for(Int_t j = 0; j < branchParticle->GetEntriesFast(); j++)
     199        {
     200
     201          gen = (GenParticle *)branchParticle->At(j);
    203202          candidate = factory->NewCandidate();
    204203
    205204          candidate->Momentum = gen->P4();
    206           candidate->Position.SetXYZT(gen->X, gen->Y, gen->Z, gen->T*1.0E3*c_light);
    207          
     205          candidate->Position.SetXYZT(gen->X, gen->Y, gen->Z, gen->T * 1.0E3 * c_light);
     206
    208207          candidate->PID = gen->PID;
    209208          candidate->Status = gen->Status;
    210      
     209
    211210          candidate->M1 = gen->M1;
    212211          candidate->M2 = gen->M2;
    … …  
    216215
    217216          candidate->Charge = gen->Charge;
    218           candidate->Mass   = gen->Mass;
    219    
     217          candidate->Mass = gen->Mass;
     218
    220219          allParticleOutputArray->Add(candidate);
    221  
     220
    222221          pdgCode = TMath::Abs(gen->PID);
    223222
    … …  
    231230          }
    232231        }
    233        
     232
    234233        modularDelphes->ProcessTask();
    235234
    … …  
    242241        ++eventCounter;
    243242      }
    244  
     243
    245244      progressBar.Update(eventCounter, eventCounter, kTRUE);
    246245      progressBar.Finish();
    247246
    248247      inputFile->Close();
    249    
     248
    250249      delete treeReader;
    251      
    252250    }
    253251
    … …  
    262260    delete outputFile;
    263261    delete chain;
    264    
     262
    265263    return 0;
    266264  }

  • readers/DelphesSTDHEP.cpp

    r45e58be r341014c  
    1717 */
    1818
    19 #include <stdexcept>
    2019#include <iostream>
    2120#include <sstream>
     21#include <stdexcept>
    2222
    2323#include <signal.h>
    2424
     25#include "TApplication.h"
    2526#include "TROOT.h"
    26 #include "TApplication.h"
    27 
     27
     28#include "TDatabasePDG.h"
    2829#include "TFile.h"
     30#include "TLorentzVector.h"
    2931#include "TObjArray.h"
     32#include "TParticlePDG.h"
    3033#include "TStopwatch.h"
    31 #include "TDatabasePDG.h"
    32 #include "TParticlePDG.h"
    33 #include "TLorentzVector.h"
    34 
    35 #include "modules/Delphes.h"
     34
    3635#include "classes/DelphesClasses.h"
    3736#include "classes/DelphesFactory.h"
    3837#include "classes/DelphesSTDHEPReader.h"
    39 
     38#include "modules/Delphes.h"
     39
     40#include "ExRootAnalysis/ExRootProgressBar.h"
     41#include "ExRootAnalysis/ExRootTreeBranch.h"
    4042#include "ExRootAnalysis/ExRootTreeWriter.h"
    41 #include "ExRootAnalysis/ExRootTreeBranch.h"
    42 #include "ExRootAnalysis/ExRootProgressBar.h"
    4343
    4444using namespace std;
    … …  
    7474  if(argc < 3)
    7575  {
    76     cout << " Usage: " << appName << " config_file" << " output_file" << " [input_file(s)]" << endl;
     76    cout << " Usage: " << appName << " config_file"
     77         << " output_file"
     78         << " [input_file(s)]" << endl;
    7779    cout << " config_file - configuration file in Tcl format," << endl;
    7880    cout << " output_file - output file in ROOT format," << endl;
    … …  
    177179      reader->Clear();
    178180      readStopWatch.Start();
    179       while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) &&
    180         reader->ReadBlock(factory, allParticleOutputArray,
    181         stableParticleOutputArray, partonOutputArray) && !interrupted)
     181      while((maxEvents <= 0 || eventCounter - skipEvents < maxEvents) && reader->ReadBlock(factory, allParticleOutputArray, stableParticleOutputArray, partonOutputArray) && !interrupted)
    182182      {
    183183        if(reader->EventReady())
    … …  
    215215
    216216      ++i;
    217     }
    218     while(i < argc);
     217    } while(i < argc);
    219218
    220219    modularDelphes->FinishTask();
Note: See TracChangeset for help on using the changeset viewer.