network.h

Go to the documentation of this file.

#ifndef NETWORK_H
#define NETWORK_H
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <math.h>
#include <random>
#include <time.h>
#include <vector>
#include <unistd.h>
#include <algorithm>
#include <ctime>
#include <chrono>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <stddef.h>
#include "vel.h"

#include "helper_funcs.h"
#include "crack.h"
using namespace std;

const float PBC_vector[DIM] = {MAXBOUND_X*1.1, 0};
const float vel[DIM] = {vel_x, vel_y};

class Network {
public:
    Network();
    Network(Network const & source);
    Network(string& fname, bool from_dump = false);
    virtual ~Network();
    Network const & operator=(Network const & other);
    virtual void build_network();
    void side_nodes(float max_x = MAXBOUND_X, float max_y = MAXBOUND_Y);
    void remove_duplicates(int&);
    // add long range edges in the network
    void add_long_range_egdes_y(int, float);
    void add_long_range_egdes_random(int, float);
    void load_from_dump(string&);
    void apply_crack(Cracklist &);
    virtual void load_network(string&);
    virtual void malloc_network();
    void make_edge_connections(float dely_allowed = 10.0);
    virtual void get_forces(bool);
    virtual void move_top_plate();
    virtual void get_plate_forces(float*, int);
    virtual void optimize(float eta = 0.1, float alpha = 0.9, int max_iter = 800);
    virtual void qd_optimize(float C = 0.001, int max_iter = 800);


    float get_weight();
    float set_weight(float);
    bool get_stats(float force_threshold = 1000.0);
    int get_current_edges();
    virtual void plotNetwork(int, bool);
    virtual void clear();
    void copy(Network const & source);
    void dump(int,bool first_time = false);

    bool cracked;       
    int n_nodes;        
    int n_elems;        

    int n_rside;        
    int n_lside;        
    int n_bside;        
    int n_tside;        

    float * R;          
    int * edges;        

    float * forces;     
    float * damage;     
    float * L;          
    bool* PBC;          

    int* lsideNodes;    
    int* rsideNodes;    
    int* tsideNodes;    
    int* bsideNodes;    
    
    bool initialized;   

    float __init_force; 
    
    float weight_multiplier = 1.0; 
    int iter_offset = 0;    
    //add moving nodes to speed up force
    int* moving_nodes;  
    int n_moving;       
};

#endif