CDeltaMax.h

Go to the documentation of this file.

#ifndef CDeltaMax_H
#define CDeltaMax_H

#include "Vector.h"
#include <algorithm>
#include <vector>
#include <iostream>
#include <iomanip>

using namespace std;

class CWall;
class Particle;

class CDeltaMax {
public:
        CDeltaMax() {delta=0; pParticle=-1; pWall=-1; time=-1;}
        
        CDeltaMax(Mdouble delta_, int pParticle_, int pWall_, Mdouble time_) {  
                delta = delta_;
                pParticle = pParticle_;
                pWall = pWall_;
                time = time_;
        }
        
        CDeltaMax (const CDeltaMax &ts) {
                delta = ts.delta;
                pParticle = ts.pParticle;
                pWall = ts.pWall;
                time = ts.time;
        }
        
        void print(std::ostream& os) {
                os << "delta:" << delta 
                        << ", particle:" << pParticle
                        << ", wall:" << pWall 
                        << ", time:" << time;
        }
        
        friend inline std::ostream& operator<<(std::ostream& os, const CDeltaMax &p) 
        {
                os << p.delta << " " << p.pParticle << " " << p.pWall << " " << p.time;
                return os;
        }       
        
        friend inline std::istream& operator>>(std::istream& is, CDeltaMax &p) 
        {
                is >> p.delta >> p.pParticle >> p.pWall >> p.time;
                return is;
        }
        
//member variables
        
        Mdouble delta;
        int pParticle;
        int pWall;
        Mdouble time;
};

class CDeltaMaxs : public vector<CDeltaMax> {
public:
        struct check_spring_time : public binary_function<CDeltaMax,Mdouble,bool>
        {
                bool operator() (const CDeltaMax a, const Mdouble b) const {return(a.time<b);}
        };
        
        Mdouble* select_particle(int P, Mdouble time_, Mdouble dt) {
                //Remove_if reconstructs the vector with only elements passing the check_spring_time function
                //Erase removes the end of the vector
                erase(remove_if(begin(),end(),bind2nd(check_spring_time(),time_)),end());       
                
                //Loops over all Springs ant returns the correct one (if it exists)
                for (CDeltaMaxs::iterator it=begin(); it!=end();it++){
                        if (it->pParticle==P)
                        {
                                it->time=time_+dt; 
                                return &it->delta;
                        }
                }
                
                //if not, create it
                push_back(CDeltaMax(0,P,-1,time_+dt));  
                return &back().delta;
        }

        Mdouble* select_wall(int W, Mdouble time_, Mdouble dt) {
                //Remove_if reconstructs the vector with only elements passing the check_spring_time function
                //Erase removes the end of the vector
                erase(remove_if(begin(),end(),bind2nd(check_spring_time(),time_)),end());
                
                //Loops over all Springs ant returns the correct one (if it exists)     
                for (CDeltaMaxs::iterator it=begin(); it!=end(); it++)
                {
                        if (it->pWall==W)
                        {
                                it->time=time_+dt; 
                                return &it->delta;
                        }
                }
                
                //if not, create it
                push_back(CDeltaMax(0,-1,W,time_+dt));          
                return &back().delta;
        }
        
        void reset() {
                clear();
                reserve(13);
        }
        
        void print(std::ostream& os, Mdouble time_) {
                os << "Delta max's: N=" << size() << endl;
                for (CDeltaMaxs::iterator it=begin(); it!=end(); it++)
                        if (it->time>=time_) {
                                        it->print(os); os << endl; 
                        }
        }

public:
        friend inline std::ostream& operator<<(std::ostream& os, const CDeltaMaxs &p) 
        {
                os << p.size() << " ";
                for (unsigned int i=0; i<p.size(); i++) os << p[i] << " ";
                return os;
        }       
        
        friend inline std::istream& operator>>(std::istream& is, CDeltaMaxs &p) 
        {
                int n; is >> n; p.resize(n);
                for (unsigned int i=0; i<p.size(); i++) is >> p[i];
                return is;
        }

};

#endif