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());
          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