ParticleHandler.h

Go to the documentation of this file.

#ifndef ParticleHandler_H
#define ParticleHandler_H

#include "CParticle.h"
#include <limits> //Used for DBL_MAX

using namespace std;

class ParticleHandler
{
        public:
        ParticleHandler()
        {
                maxParticles=0;
                #ifdef CONSTUCTOR_OUTPUT
                        cerr << "ParticleHandler() finished" << endl;
                #endif                          
        }
        
        ParticleHandler(const ParticleHandler &pH)
        {
                cout<<"ParticleHandler copy constructor"<<endl;
                for (unsigned int i=0;i<pH.particles.size();i++)
                {
                        addParticle(pH.particles[i]->copy());
                }
                #ifdef CONSTUCTOR_OUTPUT
                        cerr << "ParticleHandler(const ParticleHandler &pH) finished" << endl;
                #endif          
        }
        
        ParticleHandler operator = (const ParticleHandler right)
        {
                cout<<"ParticleHandler assignment opperator"<<endl;
                  if (this != &right) 
                  {
                        for (unsigned int i=0;i<right.particles.size();i++)
                        {
                                addParticle(right.particles[i]->copy());
                        }
                        
                }
                return *this;
        }
        
        ~ParticleHandler()
        {
                for(vector<Particle*>::iterator it = particles.begin(); it!=particles.end();it++)
                {
                        delete *it;
                }
        }
        
        
        
        void copyAndAddParticle(Particle &P)
        {
                //Puts the particle in the Particle list
                particles.push_back(P.copy());
                //Set the index of the particle
                particles.back()->set_Index(particles.size()-1); 
                //Update the maximum number of Particles
                if(particles.size()>maxParticles) maxParticles=particles.size();
        }
        
        void addParticle(Particle* P)
        {
                //Puts the particle in the Particle list
                particles.push_back(P);
                //Set the index of the particle
                particles.back()->set_Index(particles.size()-1);
                //Update the maximum number of Particles
                if(particles.size()>maxParticles) maxParticles=particles.size();
        }       

        void removeParticle(int IP)
        {
                //Physically remove Particle
                delete particles[IP];
                //Copy the pointer to the last Particle to position p
                particles[IP] = particles.back();
                //Set the correct (new) index
                particles[IP]->set_Index(IP);
                //Remove the (now Mdouble) reference to that last Particle
                particles.pop_back();
                
                for(unsigned int i=0;i<particles[IP]->get_TangentialSprings().size();)
                {
                        if (particles[IP]->get_TangentialSprings()[i].pParticle>IP)
                        {
                                int JP=particles[IP]->get_TangentialSprings()[i].pParticle;
                                
                                //Copy Tangentalspring to new location
                                CTangentialSpring CTS=particles[IP]->get_TangentialSprings()[i];
                                CTS.pParticle=IP;
                                particles[JP]->get_TangentialSprings().push_back(CTS);
                                
                                //Remove now unused tangentialspring
                                particles[IP]->get_TangentialSprings()[i]=particles[IP]->get_TangentialSprings().back();
                                particles[IP]->get_TangentialSprings().pop_back();
                        }       else i++;                               
                }       
        }
        
        void removeLastParticle()
        {
                //Physically removes Particle
                delete particles.back();
                //Remove the (now Mdouble) reference to that last Particle
                particles.pop_back();
        }
        
        
        Particle* get_SmallestParticle(){
                if (!particles.size()) cerr << "Warning: No particles to set get_SmallestParticle()" << endl;
                Particle* p = NULL;
                Mdouble minRadius = numeric_limits<Mdouble>::max();
                for (unsigned int i=0; i<particles.size(); i++) {
                        if (particles[i]->get_Radius()<minRadius) {
                                minRadius=particles[i]->get_Radius(); 
                                p = particles[i]; 
                        }
                }               
                return p;
        }
        
        Particle* get_LightestParticle(){
                if (!particles.size()) cerr << "Warning: No particles to set get_LightestParticle()" << endl;
                Particle* p = NULL;
                Mdouble minMass = numeric_limits<Mdouble>::max();
                for (unsigned int i=0; i<particles.size(); i++) {
                        if (particles[i]->get_Mass()<minMass) {
                                minMass=particles[i]->get_Mass(); 
                                p = particles[i]; 
                        }
                }
                return p;
        }
        
        Particle* get_LargestParticle(){
                if (!particles.size()) cerr << "Warning: No particles to set get_LargestParticle()" << endl;
                Particle* p = NULL;
                Mdouble maxRadius = 0;
                for (unsigned int i=0; i<particles.size(); i++) { 
                        if (particles[i]->get_Radius()>maxRadius) {
                                maxRadius=particles[i]->get_Radius(); 
                                p = particles[i]; 
                        }
                }
                return p;
        }
        
        void clear()
        {
                while (particles.size()>0)
                        removeLastParticle();
        }
        
        Particle* get_Particle(unsigned int p) {if (p<particles.size()) return particles[p]; else {cerr<<"No particle exist with index "<<p<<endl; return NULL;}}
        
        Particle* back() {return particles.back();}
        
        unsigned int get_NumberOfParticles() {return particles.size();}
        
        unsigned int get_StorageCapacity() {return particles.capacity();}
        
        unsigned int get_MaximumParticles() {return maxParticles;}
        
        void set_StorageCapacity(unsigned int N){particles.reserve(N);}
        
        vector<Particle*>::iterator begin() {return particles.begin();}
        vector<Particle*>::iterator end() {return particles.end();}
        
        private:
        vector<Particle*> particles;
        unsigned int maxParticles;
        
};

#endif