establish frame.

build

Project (PRODATA)

cmake_minimum_required(VERSION 2.8)

set(CMAKE_VERBOSE_MAKEFILE OFF)

SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)

Message (STATUS "PRODATA_BINARY_DIR = " ${PRODATA_BINARY_DIR})

Message (STATUS "PRODATA_SOURCE_DIR = " ${PRODATA_SOURCE_DIR})

Set(CMAKE_C_COMPILER "mpicc")

Set(CMAKE_CXX_COMPILER "mpicxx")

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")  

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")  

#FIND_PACKAGE( OpenMP REQUIRED)  

if(OPENMP_FOUND)  

    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")  

    message(STATUS "OpenMP_C_FLAGS = " ${OpenMP_C_FLAGS})  

    message(STATUS "OpenMP_CXX_FLAGS = " ${OpenMP_CXX_FLAGS})  

    message(STATUS "OpenMP_EXE_LINKER_FLAGS = " ${OpenMP_EXE_LINKER_FLAGS})  

endif()  

Find_Package(GEOS)

Message(STATUS "include and lib " ${GEOS_INCLUDE_DIR} " " ${GEOS_LIB_DIR})

IF(GEOS_FOUND)

    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GEOS_C_FLAGS}")  

    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GEOS_CXX_FLAGS}")  

    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${GEOS_EXE_LINKER_FLAGS}")  

    message(STATUS "GEOS_C_FLAGS = " ${GEOS_C_FLAGS})  

    message(STATUS "GEOS_CXX_FLAGS = " ${GEOS_CXX_FLAGS})  

    message(STATUS "GEOS_EXE_LINKER_FLAGS = " ${GEOS_EXE_LINKER_FLAGS})  

    Message(STATUS "GEOS_INCLUDE_DIR = " ${GEOS_INCLUDE_DIR})

    Message(STATUS "GEOS_LINK_DIR = " ${GEOS_LINK_DIR})

ENDIF(GEOS_FOUND)

Message(STATUS "CMAKE_C_FLAGS = " ${CMAKE_C_FLAGS})

Message(STATUS "CMAKE_CXX_FLAGS = " ${CMAKE_CXX_FLAGS})

Message(STATUS "CMAKE_EXE_LINKER_FLAGS = " ${CMAKE_EXE_LINKER_FLAGS})

Add_subdirectory (src bin)

if(0)

message(STATUS "CMAKE_C_FLAGS = " ${CMAKE_C_FLAGS})

message(STATUS "CMAKE_C_FLAGS_DEBUG = " ${CMAKE_C_FLAGS_DEBUG})

message(STATUS "CMAKE_C_FLAGS_MINSIZEREL = " ${CMAKE_C_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_C_FLAGS_RELEASE = " ${CMAKE_C_FLAGS_RELEASE})

message(STATUS "CMAKE_C_FLAGS_RELWITHDEBINFO = " ${CMAKE_C_FLAGS_RELWITHDEBINFO})

message(STATUS "CMAKE_CXX_FLAGS = " ${CMAKE_CXX_FLAGS})

message(STATUS "CMAKE_CXX_FLAGS_DEBUG = " ${CMAKE_CXX_FLAGS_DEBUG})

message(STATUS "CMAKE_CXX_FLAGS_MINSIZEREL = " ${CMAKE_CXX_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_CXX_FLAGS_RELEASE = " ${CMAKE_CXX_FLAGS_RELEASE})

message(STATUS "CMAKE_CXX_FLAGS_RELWITHDEBINFO = " ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})

message(STATUS "CMAKE_EXE_LINKER_FLAGS = " ${CMAKE_EXE_LINKER_FLAGS})

message(STATUS "CMAKE_EXE_LINKER_FLAGS_DEBUG = " ${CMAKE_EXE_LINKER_FLAGS_DEBUG})

message(STATUS "CMAKE_EXE_LINKER_FLAGS_MINSIZEREL = " ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_EXE_LINKER_FLAGS_RELEASE = " ${CMAKE_EXE_LINKER_FLAGS_RELEASE})

message(STATUS "CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO = " ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO})

message(STATUS "CMAKE_MODULE_LINKER_FLAGS = " ${CMAKE_MODULE_LINKER_FLAGS})

message(STATUS "CMAKE_MODULE_LINKER_FLAGS_DEBUG = " ${CMAKE_MODULE_LINKER_FLAGS_DEBUG})

message(STATUS "CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL = " ${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_MODULE_LINKER_FLAGS_RELEASE = " ${CMAKE_MODULE_LINKER_FLAGS_RELEASE})

message(STATUS "CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO = " ${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO})

message(STATUS "CMAKE_SHARED_LINKER_FLAGS = " ${CMAKE_SHARED_LINKER_FLAGS})

message(STATUS "CMAKE_SHARED_LINKER_FLAGS_DEBUG = " ${CMAKE_SHARED_LINKER_FLAGS_DEBUG})

message(STATUS "CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL = " ${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_SHARED_LINKER_FLAGS_RELEASE = " ${CMAKE_SHARED_LINKER_FLAGS_RELEASE})

message(STATUS "CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO = " ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO})

message(STATUS "CMAKE_STATIC_LINKER_FLAGS = " ${CMAKE_STATIC_LINKER_FLAGS})

message(STATUS "CMAKE_STATIC_LINKER_FLAGS_DEBUG = " ${CMAKE_STATIC_LINKER_FLAGS_DEBUG})

message(STATUS "CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL = " ${CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL})

message(STATUS "CMAKE_STATIC_LINKER_FLAGS_RELEASE = " ${CMAKE_STATIC_LINKER_FLAGS_RELEASE})

message(STATUS "CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO = " ${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO})

endif()

FIND_PATH(GEOS_INCLUDE_DIR geos.h /usr/include/geos /usr/local/include/geos)

FIND_LIBRARY(GEOS_LIBRARY NAMES geos PATH /usr/lib /usr/local/lib /usr/lib64) 

FIND_PATH(GEOS_LINK_DIR libgeos.so /usr/lib/geos /usr/local/lib /usr/local/lib/geos /usr/lib64) 

IF (GEOS_INCLUDE_DIR AND GEOS_LIBRARY)

   SET(GEOS_FOUND TRUE) 

ENDIF (GEOS_INCLUDE_DIR AND GEOS_LIBRARY) 

IF (GEOS_FOUND)

   IF (NOT GEOS_FIND_QUIETLY)

      MESSAGE(STATUS "Found Hello: ${GEOS_LIBRARY}")

   ENDIF (NOT GEOS_FIND_QUIETLY)

ELSE (GEOS_FOUND)

   IF (GEOS_FIND_REQUIRED)

      MESSAGE(FATAL_ERROR "Could not find geos library!") 

   ENDIF (GEOS_FIND_REQUIRED)

ENDIF (GEOS_FOUND)

#ifndef _HOME_h

#define _HOME_h

#include <stdio.h>

#include <stdarg.h>

#include <unistd.h>

#include <errno.h>

#include <math.h>

#include <time.h>

#include <vector>

#include <string>

#include <cstring>

#include <string>

#include <vector>

#define real8 double

using namespace std;

/*

 *      Define a structure containing all items corresponding to

 *      all command line options that have associated values.  This

 *      gives us an easy way to pass the command line arg values around

 *      to various functions.

 */

typedef struct {

        double  burgMag;

        int     seed;

        int     type;

        std::vector<string>      inpFiles;

        std::vector<string>      outFiles;

}InArgs_t;

/*

 *      Define a structure to hold a nodal configuration type, name, and

 *      a pointer to the function to invoke to create that type of nodal

 *      configuration.

 */

typedef struct {

        int   funcType;

        const char  *funcName;

/*

        void  (* func)();

*/

} FuncData_t;

/*

 *      Define an integer identifier to be associated with each

 *      posible command line argument.  To be used to index the

 *      option-specific data in the optList array below.

 */

typedef	enum{

    OPT_HELP,

    OPT_INPFILE,

    OPT_OUTFILE,

    OPT_SEED,

    OPT_TYPE,

	OPT_MAX

}OPT_t;

typedef	enum{

	FTYPE_AVERAGE_LINES = 0,

    FTYPE_PROC_EXTEND_DIS,

	FTYPE_MAX

}FTYPE_t;

/*

 *      Define a structure to hold a command line option's id (type),

 *      name, the shortest possible unique abbreviation of the option

 *      name, and the number of parameters paired with the opt.

 */

typedef struct {

        int         optType;

        const char  *optName;

        int         optMinAbbrev;

        int         optPaired;

} Option_t;

#endif 

Set (SRCS 

    Main.cpp )

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -Wno-unknown-pragmas -DPARALLEL=1 " )

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 " )

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ")

add_executable(prodata ${SRCS})

add_definitions( -DPARALLEL=1)

INCLUDE_DIRECTORIES(../include)    

target_link_libraries(prodata m pthread)

Install(TARGETS prodata

        RUNTIME DESTINATION ${PARADIS_SOURCE_DIR}/bin)