particle_base.h

Go to the documentation of this file.

//Copyright 2008-2010 Thomas A Caswell
//tcaswell@uchicago.edu
//http://jfi.uchicago.edu/~tcaswell
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 3 of the License, or (at
//your option) any later version.
//
//This program is distributed in the hope that it will be useful, but
//WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, see <http://www.gnu.org/licenses>.
//
//Additional permission under GNU GPL version 3 section 7
//
//If you modify this Program, or any covered work, by linking or
//combining it with MATLAB (or a modified version of that library),
//containing parts covered by the terms of MATLAB User License, the
//licensors of this Program grant you additional permission to convey
//the resulting work.
//standard incldues

#ifndef PARTICLE_BASE
#define PARTICLE_BASE
#include <vector>
#include <iostream>
#include <set>


#include <complex>

//local includes
#include "part_def.h"



#include "enum_utils.h"


namespace utilities
{
class Wrapper_in;
}

namespace tracking{



class particle_base{
  
public:
    
  //clean this up/use inline intilization
  //  particle_base(Wrapper_in * i_data, Wrapper_out* o_out, 
  //    int i_ind);

  particle_base(int i_ind,int frame=0);

  particle_base(int ind, utilities::Tuplef pos,int frame = 0);
  
  
  particle_base(const particle_base &p);

  
  
  ~particle_base(){}


  //A program generated global unique id, useful for tracking, comparing
  //particles and that sort of thing that does not depends on
  //properly parsing the data or the data being handed in behaving in
  //any sort of nice way, but this does mean that the particle
  //objects just got 32bits bigger
  //int unq_id_;

  void print() const;

  
  float               get_value(utilities::D_TYPE type,float & val        ) const;
  int                 get_value(utilities::D_TYPE type,int &val    ) const;
  std::complex<float> get_value(utilities::D_TYPE type,std::complex<float>& val) const;


  template <class T>
  T get_wrapper_value(utilities::D_TYPE type,T & val) const;

  const utilities::Tuplef & get_position() const{
    return position_;}
  int get_ind()const
  {
    return ind_;
  }
  int get_frame()const
  {
    return frame_;
  }
  
  float distancesq(const particle_base* part_in) const;

  
  const utilities::Tuplef get_disp(const particle_base * part_in)const;

  
  float get_r(const utilities::Tuplef & origin) const;
  float get_theta(const utilities::Tuplef & origin) const;


  void sort_neighborhood();
  
  bool no_neighborhood_repeats()const;
  
  bool add_to_neighborhood(const particle* in);
  static float get_max_range()
  {
    return max_neighborhood_range_;
    
  }


  void fill_phi_6();
  std::complex<float> compute_phi_6()const;

  std::complex<float> get_scaler_order_pram()const
  {
    return s_order_parameter_;
  }
  unsigned int get_neighborhood_size()const
  {
    return neighborhood_.size();
  }
  const std::vector<const particle*> get_neighborhood() const
  {
    return neighborhood_;
  }
  

  

  static void intialize_wrapper_in(const utilities::Wrapper_in* in);

  static void clear_wrapper_in();

  static void set_neighborhood_range(float in)
  {
    max_neighborhood_range_ = in;
  }
  static float get_neighborhood_range()
  {
    return max_neighborhood_range_;
  }
  
  

protected:
  //A running total of all particles created 
  //static int running_total_;
  const static utilities::Wrapper_in* wrapper_in_;
  

  int ind_;
  
  utilities::Tuplef position_;
  
  int frame_;


  std::vector<const particle*> neighborhood_;
  
  static float max_neighborhood_range_;

  std::complex<float> s_order_parameter_;
  

  
private:
  void fill_position();
  void priv_init();

  bool lthan(const particle_base* a,const particle_base* b)const;
  
  
};
}
#endif


/*
#ifndef PARTICLE_NEI
#define PARTICLE_NEI



   Class for particles that carry around with them their neighbor
   information.  Implements this list as a vector, this is just here
   so I don't forget I planned this and try to re implement it a
   different way.
 
class particle_neighbor : public particle_track{
protected:
  vector <particle_neighbor*> neighbors;
public:
  //getter, setter, etc functions
};


#endif
*/