CTangentialSpring.h

Go to the documentation of this file.

#ifndef CTANGENTIALSPRING_H
#define CTANGENTIALSPRING_H

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

using namespace std;

class CWall;
class Particle;

class CTangentialSpring {
public:
        CTangentialSpring() {
                delta.set_zero(); 
                RollingSpring.set_zero(); 
                TorsionSpring.set_zero(); 
                pParticle=-1; 
                pWall=-1; 
                time=-1; 
                sliding = false; 
        }
        
        CTangentialSpring(int pParticle_, int pWall_, Mdouble time_) {  
                delta.set_zero();
                RollingSpring.set_zero();
                TorsionSpring.set_zero();
                pParticle = pParticle_;
                pWall = pWall_;
                time = time_;
                sliding = false;
                //~ cout << endl << "D" << endl;
        }
        
        CTangentialSpring (const CTangentialSpring &ts) {
                delta = ts.delta;
                RollingSpring = ts.RollingSpring;
                TorsionSpring = ts.TorsionSpring;
                pParticle = ts.pParticle;
                pWall = ts.pWall;
                time = ts.time;
                sliding = ts.sliding;
                //~ cout << "c";
        }
        
        void print(std::ostream& os) {
                os << "delta:" << delta 
                        << ", particle:" << pParticle
                        << ", wall:" << pWall 
                        << ", time:" << time;
        }
        
        friend inline std::ostream& operator<<(std::ostream& os, const CTangentialSpring &p) 
        {
                os << p.delta << " " << p.RollingSpring << " " << p.TorsionSpring << " " << p.pParticle << " " << p.pWall << " " << p.time;
                return os;
        }       
        
        friend inline std::istream& operator>>(std::istream& is, CTangentialSpring &p) 
        {
                is >> p.delta >> p.RollingSpring >> p.TorsionSpring >> p.pParticle >> p.pWall >> p.time;
                return is;
        }
        
        Vec3D delta;
        Vec3D forcedelta;
        Vec3D RollingSpring;
        Vec3D TorsionSpring;
        int pParticle;
        int pWall;
        Mdouble time;

        bool sliding;
};

class CTangentialSprings : public vector<CTangentialSpring> {
public:

        struct check_spring_time : public binary_function<CTangentialSpring,Mdouble,bool>
        {
                bool operator() (const CTangentialSpring a, const Mdouble b) const {return(a.time<b);}
        };
        
        vector<int> to_be_erased(Mdouble time) {
                vector<int> retval;
                for (unsigned int i=0; i<size(); i++)
                        if (operator[](i).time<time) {
                                retval.push_back(i);
                                //cout << "to be erased " << time << " " << operator[](i).pParticle << " " << operator[](i).pWall << " " << size() << endl;
                        }
                return retval;
        }

        void to_erase(Mdouble time) {
                erase(remove_if(begin(),end(),bind2nd(check_spring_time(),time)),end());        
        }

        CTangentialSpring* select_particle_spring(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 (CTangentialSprings::iterator it=begin(); it!=end();it++){
                        if (it->pParticle==P)
                        {
                                it->time=time_+dt; 
                                return &(*it);
                        }
                }
                
                //if not, create it
                push_back(CTangentialSpring(P,-1,time_+dt));
                return &(back());
        }

        CTangentialSpring* select_wall_spring(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 (CTangentialSprings::iterator it=begin(); it!=end();it++){
                        if (it->pWall==W)
                        {
                                it->time=time_+dt; 
                                return &(*it);
                        }
                }
                
                //if not, create it
                //~ cout << "created pw " << time_ << " " << W << endl;
                push_back(CTangentialSpring(-1,W,time_+dt));
                return &(back());
        }

        void reset() {
                clear();
                reserve(13);
        }
        
        void print(std::ostream& os, Mdouble time_) {
                os << "Tangential Springs: N=" << size() << endl;
                for (CTangentialSprings::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 CTangentialSprings &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, CTangentialSprings &p) 
        {
                //should return empty spring if read from is failed
                int n; is >> n; 
                if (is.fail()) {
                        p.resize(0);
                } else {
                        p.resize(n);
                        for (unsigned int i=0; i<p.size(); i++) is >> p[i];
                }
                return is;
        }

};

#endif