hasurface.h

Go to the documentation of this file.

#if !defined(HASURFACE_H)
#define HASURFACE_H


#include "hastl.h"
#include "haconst.h"
#include "halinalg.h"
#include "vec3d.h"
#include "object3d.h"

#define MAXVARS 10
#define MAXTIMES 10


const int MAX_ISO_VERTS = 1200000;
const double VERTEX_SCALE  = 10000.0;


class HaField3D
{
public:

        HaField3D();
        virtual ~HaField3D();

        virtual void clear();  
        void FillZeros();      

        int SaveToFile(const char* fname,      int binary=TRUE);       
        int RestoreFromFile(const char* fname, int binary=TRUE);  

        virtual void copy_from(const HaField3D& ref_field);

        virtual bool SetDimensions(int new_Nx, int new_Ny, int new_Nz); 

        int GetNx() const { return m_Nx ; } 
        int GetNy() const { return m_Ny ; } 
        int GetNz() const { return m_Nz ; } 
        
        double GetXmin() const { return xmin; } 
        double GetYmin() const { return ymin; } 
        double GetZmin() const { return zmin; } 
        double GetXmax() const { return xmax; } 
        double GetYmax() const { return ymax; } 
        double GetZmax() const { return zmax; } 

        double GetXstep() const { return xstep; } 
        double GetYstep() const { return ystep; } 
        double GetZstep() const { return zstep; } 

        bool SetGridCornersCoord(double xmin_new, double ymin_new, double zmin_new,  
                                    double xmax_new, double ymax_new, double zmax_new); 

        int GetLinIdx(int ix, int iy, int iz); 

        float* GetFieldPtr() { return m_field_data.begin(); } 

        bool GetXYZ(float& x, float& y , float& z, const int ix, const int iy, const int iz);

        float* GetValPtr( int ix, int iy, int iz); 
        float GetValue( int ix, int iy, int iz);   


        void SetValue(int ix, int iy, int iz, float val); 

        int GetClosestGridPoint( double x, double y, double z, int& ix, int& iy, int& iz); 


        double GetInterpolValAtPoint( double x, double y, double z); 

        bool grid_to_xyz_float(const int numverts, const float* vr, const float* vc, const float* vl,
                               float* xyz_coord);  

protected:
        float xmin, xmax;    
        float ymin, ymax;    
        float zmin, zmax;    
        
        float xstep;   
        float ystep;   
        float zstep;   

        int m_Nx, m_Ny, m_Nz;        
        HaVec_float m_field_data;    

};


class HaNonLocField3D_2 : public HaField3D
{
public:
        HaNonLocField3D_2();
        virtual ~HaNonLocField3D_2();

        bool SetDepth(int new_depth);
        int GetDepth() const;

        virtual void clear();
        virtual bool SetDimensions(int new_Nx, int new_Ny, int new_Nz);

        float GetValue_nloc(int ix, int iy, int iz,
                                int ir_shift, int ic_shift, int il_shift);

        float* GetValuePtr_nloc(int ix, int iy, int iz,
                                int ir_shift, int ic_shift, int il_shift);

protected:
    int depth;
        int nl_cube_size;
        HaMat_float m_nonl_field_data;

};

class ValAtPoint
{
public:
        ValAtPoint() {}
        ValAtPoint(short ir_new,short ic_new, short il_new, double new_val);

        virtual ~ValAtPoint() {}
        
        short ix;
        short iy;
        short iz;
        double val;
};

class HaNonLocField3D : public HaField3D
{
public:
        HaNonLocField3D();
        virtual ~HaNonLocField3D();

        vector< list<ValAtPoint> > fvals;

        int SaveField(HaString fname);

protected:

};


class VertexField3D
{
public:
        VertexField3D(HaField3D* new_pfld);
        ~VertexField3D();
        
        double GetX() const;
        double GetY() const;
        double GetZ() const;

        double GetVal() const;
        bool SetVal(const double new_val);

        int iy,ix,iz;

protected:
        HaField3D* pfld;
};

enum MolSurfaceType { VDW_SURF=0, SACCESS_SURF=1,SEXCL_SURF=2}; 


class HaSurface
{       
public:

        HaSurface();
        virtual ~HaSurface();

        virtual void clear();

        int     valid;       
        float   isolevel;    
        
        bool calc_isosurf( HaField3D* field, float iso_level); 

        static void main_march( float *ptGRID, int NC, int NR, int NL,
                 int LOWLEV,
                 float GLEV, float ARX, float ARY, float ARZ,
                 int NVERTS, float *VX, float *VY, float *VZ,
                 float *NX,float *NY, float *NZ,
                 int NPTS, int *VPTS, int*IVERT, int *IPTS, int *IPOLY,
                 int *ITRI);

    int CalcMolSurf(int surf_type, float solv_rad, HaMat_float& cnt_crd, HaVec_float& cnt_rad); 

// parameters to build molecular surface:
        
        static float rmin_axx_sph; 
        static float overlap_axx_sph; 
        static int    ndiv_sph;    
        static Vec3D_arr vrt_std;  
    static Vec3D_arr tcnt_std;  

        HaMat_float verts;      
        HaMat_float norms;      
        HaMat_int   tr_indx;    

        int GetNumTr()    { return tr_indx.num_cols(); }     
        int GetNumVerts() const { return verts.num_cols(); } 

        virtual int  SetNumVerts( const int new_num_verts);  
        
// tesserae surface representation 
// surface presented as patches (parts of main triangles) of the trianglulated spheres
// with a given surface area and spheres they belong to (that determine normal vectors)

        HaVec_ptr sph;  
        HaVec_double   srad; 
        HaVec_short  flag_sph; 
    Vec3D_arr   tess; 
        HaVec_double tsurf;    
        HaVec_short  itsph;   
        HaVec_short  itsph_r; 
    
        bool Print_info(ostream& sout, const int level) const; 

protected:      

};

const int MC_SIZE = 100000;
const int MV_SIZE = 100000;

extern "C"{

void gsurf_(integer* ksurf,  
           freal* rmin,     
           freal* ofac,     
           freal* rd,       
       integer* ndiv,   
           logical* ass1,   
           integer* natom,  
           logical* ghost,  
       integer*   np);    

typedef struct
{
  freal xe[MC_SIZE];
  freal ye[MC_SIZE];
  freal ze[MC_SIZE];
  freal re[MC_SIZE];
  int_2 iuse[MC_SIZE];
} csfe_type; 

typedef struct
{
        int_4  jvt1[3*60];
        int_4  jvt2[3*4];
} penta_type;

typedef struct
{
   int_4 ito[MV_SIZE];
   int_4 iso[MV_SIZE];
   int_4 isa[MV_SIZE];
   freal xp[MV_SIZE];
   freal yp[MV_SIZE];
   freal zp[MV_SIZE];
   freal ap[MV_SIZE];
} pun_type;

typedef struct
{
   doublereal cv[32*3];
   freal xc1[15360];
   freal yc1[15360];
   freal zc1[15360];
} poli_type;

extern csfe_type csfe_;
extern pun_type pun_;
extern penta_type penta_;
extern poli_type poli_;

}


class HaDisplayedSurface: public HaSurface, public Object3D
{
public:
        HaDisplayedSurface();
        virtual ~HaDisplayedSurface();
        
        virtual void clear();

// Object3D virtuals:
        
        virtual int RotateObj( const HaMat_double& rot_mat, const Vec3D& cnt);

        virtual int Translate( const Vec3D& tr_vec ); 

        bool ColourUniform(int r, int g, int b );

        virtual int SetNumVerts(const int new_num_verts);  
        HaVec_short  colors;      /* array [numverts] of color table indexes */

protected:

};


class HaDot
{
public:
    HaDot() {};
        HaDot(const double new_x, const double new_y,
                  const double new_z, const int col);

        virtual ~HaDot();
        short col;

        double GetX() const { return xpos; }
        double GetY() const { return ypos; }
        double GetZ() const { return zpos; }

        void SetX( const double new_x ) { xpos = new_x; }
        void SetY( const double new_y ) { ypos = new_y; }
        void SetZ( const double new_z ) { zpos = new_z; }

protected:

        double xpos;
        double ypos;
        double zpos;
};



class DotStruct : public Object3D
{
public:

    DotStruct();
        virtual ~DotStruct();

        vector<HaDot> dots;
        int GetCount() { return dots.size(); }

        void AddDot(double x, double y, double z, int col );

// Object3D virtual functions:

        virtual const char* GetObjName() const { return "Dot Surface"; }

        virtual int RotateObj( const HaMat_double& rot_mat, const Vec3D& cnt );

        virtual int Translate( const Vec3D& tr_vec); // Translate the object by tr_vec

};





#endif // End of !defined(HASURFACE_H)

---