G4INCLStore.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// INCL++ intra-nuclear cascade model
// Alain Boudard, CEA-Saclay, France
// Joseph Cugnon, University of Liege, Belgium
// Jean-Christophe David, CEA-Saclay, France
// Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
// Sylvie Leray, CEA-Saclay, France
// Davide Mancusi, CEA-Saclay, France
//
#define INCLXX_IN_GEANT4_MODE 1
 
#include "globals.hh"
 
#ifndef G4INCLParticleStore_hh
#define G4INCLParticleStore_hh 1
 
#include <map>
#include <set>
#include <list>
#include <string>
#include <algorithm>
 
#include "G4INCLParticle.hh"
#include "G4INCLIAvatar.hh"
#include "G4INCLBook.hh"
#include "G4INCLConfig.hh"
 
#ifdef INCLXX_IN_GEANT4_MODE
#define INCL_AVATAR_SEARCH_MinElement 1
#endif // INCLXX_IN_GEANT4_MODE
 
#if !defined(NDEBUG) && !defined(INCLXX_IN_GEANT4_MODE)
// Force instantiation of all the std::multimap<Particle*,IAvatar*> methods for
// debugging purposes
namespace G4INCL {
  class Particle;
  class IAvatar;
}
template class std::multimap<G4INCL::Particle*, G4INCL::IAvatar*>;
#endif
 
namespace G4INCL {
 
  class Store {
  public:
    Store(Config const * const config);
 
    ~Store();
 
    void add(Particle *p);
 
    void add(ParticleList const &pL);
 
    void addParticleEntryAvatar(IAvatar *a);
 
    void addParticleEntryAvatars(IAvatarList const &al);
 
    void add(IAvatar *a);
 
    IAvatarList const &getAvatars() const {
      return avatarList;
    }
 
    void addIncomingParticle(Particle * const p);
 
    void removeFromIncoming(Particle * const p) { incoming.remove(p); }
 
    inline void clearIncoming() {
      incoming.clear();
    }
 
    inline void deleteIncoming() {
      for(ParticleIter iter=incoming.begin(), e=incoming.end(); iter!=e; ++iter) {
        delete (*iter);
      }
      clearIncoming();
    }
 
    void particleHasBeenUpdated(Particle * const);
 
    void removeScheduledAvatars();
 
    IAvatar* findSmallestTime();
 
    void timeStep(G4double step);
 
    void particleHasBeenEjected(Particle * const);
 
    void addToOutgoing(Particle *p) { outgoing.push_back(p); }
 
    void addToOutgoing(ParticleList const &pl) {
      for(ParticleIter p=pl.begin(), e=pl.end(); p!=e; ++p)
        addToOutgoing(*p);
    }
 
    void particleHasBeenDestroyed(Particle * const);
 
    void particleHasEntered(Particle * const particle);
 
    ParticleList const & getIncomingParticles() const { return incoming; }
 
    ParticleList const & getOutgoingParticles() const { return outgoing; }
 
    ParticleList extractDynamicalSpectators() {
      ParticleList spectators;
      for(ParticleIter p=outgoing.begin(), e=outgoing.end(); p!=e; ++p) {
        if((*p)->isProjectileSpectator()) {
// assert((*p)->isNucleon() || (*p)->isLambda());
          spectators.push_back(*p); // add them to the list we will return
        }
      }
 
      // Now erase them from outgoing
      for(ParticleIter i=spectators.begin(); i!=spectators.end(); ++i) {
        outgoing.remove(*i);
      }
 
      return spectators;
    }
 
    ParticleList const & getParticles() const { return inside; }
 
    Book &getBook() { return theBook; };
 
    G4int countCascading() {
      G4int n=0;
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
        if(!(*i)->isTargetSpectator())
          ++n;
      }
      return n;
    }
 
    Config const * getConfig() { return theConfig; };
 
    void clear();
 
    void clearInside();
 
    void clearOutgoing();
 
    void clearAvatars();
 
    void loadParticles(std::string const &filename);
 
    G4int getLoadedA() { return loadedA; };
 
    G4int getLoadedZ() { return loadedZ; };
 
    G4double getLoadedStoppingTime() { return loadedStoppingTime; };
 
    std::string printParticleConfiguration();
 
    void writeParticles(std::string const &filename);
 
    std::string printAvatars();
 
    G4bool containsCollisions() const;
 
#if defined(INCL_AVATAR_SEARCH_FullSort) || defined(INCL_AVATAR_SEARCH_MinElement)
    static G4bool avatarComparisonPredicate(IAvatar *lhs, IAvatar *rhs) {
      return (lhs->getTime() < rhs->getTime());
    }
#endif
 
  private:
    Store(const Store &rhs);
 
    Store &operator=(Store const &rhs);
 
 
    void connectAvatarToParticle(IAvatar * const a, Particle * const p);
 
    void disconnectAvatarFromParticle(IAvatar * const a, Particle * const p);
 
    void removeAvatar(IAvatar * const a);
 
  private:
    std::multimap<Particle*, IAvatar*> particleAvatarConnections;
    typedef std::multimap<Particle*, IAvatar*>::value_type PAPair;
    typedef std::multimap<Particle*, IAvatar*>::iterator PAIter;
    typedef std::pair<PAIter, PAIter> PAIterPair;
 
    std::set<IAvatar*> avatarsToBeRemoved;
    typedef std::set<IAvatar*>::const_iterator ASIter;
 
  private:
    IAvatarList avatarList;
 
    ParticleList incoming;
 
    ParticleList inside;
 
    ParticleList outgoing;
 
    ParticleList geomSpectators;
 
    G4double currentTime;
 
    Book theBook;
 
    G4int loadedA;
 
    G4int loadedZ;
 
    G4double loadedStoppingTime;
 
    Config const * theConfig;
 
  };
}
 
#endif