版塊導(dǎo)航: 正在加載中...

應(yīng)《網(wǎng)絡(luò)安全法》要求，自2017年10月1日起，未進(jìn)行實(shí)名認(rèn)證將不得使用互聯(lián)網(wǎng)跟帖服務(wù)。為保障您的帳號(hào)能夠正常使用，請(qǐng)盡快對(duì)帳號(hào)進(jìn)行手機(jī)號(hào)驗(yàn)證，感謝您的理解與支持！

24小時(shí)熱門版塊排行榜

返回列表

xjw040

金蟲(chóng) (正式寫手)

應(yīng)助: 2 (幼兒園)
金幣: 2239.8
散金: 37
帖子: 339
在線: 257.5小時(shí)
蟲(chóng)號(hào): 629374
注冊(cè): 2008-10-18
性別: GG
專業(yè): 電化學(xué)

[求助] 在Lammps中安裝xmovie工具時(shí)，Makefile文件怎么修改X庫(kù)路徑

在Lammps中安裝xmovie工具時(shí)，Makefile文件怎么修改X庫(kù)路徑，謝謝

回復(fù)此樓

» 本帖已獲得的紅花（最新10朵）

xjw040

» 猜你喜歡

被我言中：新模板不強(qiáng)調(diào)格式了，假專家開(kāi)始管格式了已經(jīng)有3人回復(fù)
085600材料與化工求調(diào)劑已經(jīng)有5人回復(fù)
材料與化工求調(diào)劑已經(jīng)有5人回復(fù)
277調(diào)劑已經(jīng)有4人回復(fù)
290求調(diào)劑已經(jīng)有4人回復(fù)
材料工程專碩調(diào)劑已經(jīng)有3人回復(fù)
26考研求調(diào)劑已經(jīng)有6人回復(fù)
求調(diào)劑，總分315，考的生物醫(yī)藥，一志愿湖南師范大學(xué)。調(diào)劑到任何專業(yè)都可以已經(jīng)有5人回復(fù)
311求調(diào)劑已經(jīng)有7人回復(fù)
303求調(diào)劑已經(jīng)有3人回復(fù)

» 本主題相關(guān)價(jià)值貼推薦，對(duì)您同樣有幫助:

祝愿老婆文章修改后能通過(guò)，增加人氣，增加祝福，謝謝！已經(jīng)有109人回復(fù)
office 直接轉(zhuǎn)存為pdf文件(已搜索僅本帖可下載小插件) 已經(jīng)有32人回復(fù)
四種把超星文件格式轉(zhuǎn)為PDF的好辦法已經(jīng)有63人回復(fù)
【原創(chuàng)】關(guān)于endnote中Attach File后文件打不的最新解決辦法已經(jīng)有4人回復(fù)
EndNote從x4從從菜單中的import》file導(dǎo)入本地文獻(xiàn)怎么沒(méi)有反應(yīng)�。� 已經(jīng)有10人回復(fù)
【討論】編譯lammps時(shí)Makefile的修改問(wèn)題已經(jīng)有8人回復(fù)
【討論】lammps中關(guān)于fix ave/spatial命令的輸出問(wèn)題已經(jīng)有4人回復(fù)
【求助】lammps中多元化合物的晶格創(chuàng)建問(wèn)題已經(jīng)有14人回復(fù)
【求助】Lammps 多機(jī)并行的問(wèn)題已經(jīng)有11人回復(fù)
【求助】LAMMPS中非周期性邊界條件和Born-Mayer-Huggins勢(shì)函數(shù)不會(huì)設(shè)置已經(jīng)有4人回復(fù)

1樓 2012-03-05 14:21:44

已閱回復(fù)此樓關(guān)注TA 給TA發(fā)消息送TA紅花 TA的回帖

chaonie

銅蟲(chóng) (初入文壇)

應(yīng)助: 2 (幼兒園)
金幣: 59.5
帖子: 11
在線: 3.4小時(shí)
蟲(chóng)號(hào): 1638734
注冊(cè): 2012-02-24

【答案】應(yīng)助回帖

★ ★ ★ ★ ★ ★ ★ ★
感謝參與，應(yīng)助指數(shù) +1
jiaoyixiong(金幣+3): 鼓勵(lì)交流 2012-03-07 07:56:37
xjw040(金幣+5): ★有幫助謝謝您的熱情幫助！ 2012-03-08 13:42:12

我大概記得我當(dāng)初是把Makefile離得什么東西給改了，然后就可以make了，
這是我的Makefile，貌似是出事文件某一個(gè)地方?jīng)]有寫全，所以沒(méi)辦法運(yùn)行。

CC = gcc
LN = gcc
OPTIM = -O2 -finline-functions -g
XLIBDIR = -L/usr/X11R6/lib
XINCLUDE =
DEFINES = -DMISSINGDEFS -D_POSIX_SOURCE -DUSEPRIVATE -DINCL_FLOAT
WARNS = -Wimplicit -Wunused -Wmissing-prototypes
CCOPTS = -c $(OPTIM) $(DEFINES) $(WARNS) $(XINCLUDE)
LNOPTS = $(OPTIM)

#LIBS = $(XLIBDIR) -lX11 -lXaw -lm

# try this version on a Mac
LIBS = $(XLIBDIR) -lX11 -lXaw -lXt -lXext -lXmu -lXpm

OBJS = xmovie.o \
control.o \
scene.o \
read.o \
hpsort.o

EXES = xmovie dummy tobinary toascii

.c.o:
$(CC) $(CCOPTS) $*.c

xmovie: $(OBJS)
$(CC) $(CCOPTS) version.c
$(LN) -o xmovie $(LNOPTS) version.o $(OBJS) $(LIBS)

xmovie.o: xmovie.h resource.h xmovie.c
control.o: xmovie.h control.c
scene.o: xmovie.h scene.c
read.o: xmovie.h read.c
hpsort.o: hpsort.c

clean:
rm -f *.o *~ $(EXES)

tar:
tar cvf xmovie.tar Makefile *.c *.h
compress xmovie.tar
uuencode xmovie.tar.Z xmovie.tar.Z > xmovie.tar.Z.uu

clean_obj:
rm -f *.o

all: $(EXES)

dummy: dummy.o
$(LN) $(LNOPTS) -o dummy dummy.o -lm

dummy.o: dummy.c

toascii: toascii.o
$(LN) $(LNOPTS) -o toascii toascii.o

toascii.o: toascii.c

tobinary: tobinary.o
$(LN) $(LNOPTS) -o tobinary tobinary.o

tobinary.o: tobinary.c

贊一下(1人)

回復(fù)此樓

2樓2012-03-07 01:32:44

已閱回復(fù)此樓關(guān)注TA 給TA發(fā)消息送TA紅花 TA的回帖

xjw040

金蟲(chóng) (正式寫手)

應(yīng)助: 2 (幼兒園)
金幣: 2239.8
散金: 37
帖子: 339
在線: 257.5小時(shí)
蟲(chóng)號(hào): 629374
注冊(cè): 2008-10-18
性別: GG
專業(yè): 電化學(xué)

送鮮花一朵

不好意思，又要麻煩你了。
xuejunwei@xuejunwei-VirtualBox:~/software/lammps-11Jan12/tools/xmovie$ make
gcc -c -O2 -finline-functions -g -DMISSINGDEFS -D_POSIX_SOURCE -DUSEPRIVATE -DINCL_FLOAT -Wimplicit -Wunused -Wmissing-prototypes version.c
gcc -o xmovie -O2 -finline-functions -g version.o xmovie.o control.o scene.o read.o hpsort.o -L/usr/X11R6/lib -lX11 -lXaw -lXt -lXext -lXmu -lXpm
read.o: In function `get_positions':
/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:533: undefined reference to `fmod'
/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:526: undefined reference to `fmod'
/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:535: undefined reference to `fmod'
/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:528: undefined reference to `fmod'
/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:524: undefined reference to `fmod'
read.o:/home/xuejunwei/software/lammps-11Jan12/tools/xmovie/read.c:530: more undefined references to `fmod' follow
collect2: ld 返回 1
make: *** [xmovie] 錯(cuò)誤 1
改了Makefile之后出現(xiàn)這樣的問(wèn)題。

贊一下

回復(fù)此樓

3樓2012-03-08 13:43:53

已閱回復(fù)此樓關(guān)注TA 給TA發(fā)消息送TA紅花 TA的回帖

chaonie

銅蟲(chóng) (初入文壇)

應(yīng)助: 2 (幼兒園)
金幣: 59.5
帖子: 11
在線: 3.4小時(shí)
蟲(chóng)號(hào): 1638734
注冊(cè): 2012-02-24

【答案】應(yīng)助回帖

★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★ ★
jiaoyixiong(金幣+3): 鼓勵(lì)交流 2012-03-09 07:48:34
xjw040(金幣+15): ★★★很有幫助太感謝了�。�！ 2012-03-09 11:39:35

/* **************************************************************** */
/* functions to read data from files */

#include
#include
#include
#include
#include

/* commented this out for SGI gcc compiler
#ifdef INCL_FLOAT
double strtod(char *s, char **t);
long strtol(char *s, char **t, int base);
#endif
*/

#include

extern FILE *popen(const char *, const char *);
extern int    pclose(FILE *);

#include "xmovie.h"

#define LINELEN 256
#define WHITESPACE " \f\n\r\t\v"
#define SEPARATORS ",;:" WHITESPACE
#define NPRINT 500
#define NREAD 50
#define NBREAD 2000

#define ERROR -1
#define END_OF_FILE 1
#define BEING_NICE 2
#define READ_OK 3
#define LOOK_FOR_ITEM 10
#define LOOK_FOR_BOUNDS 11
#define LOOK_FOR_POSITIONS 12
#define LOOK_FOR_TIME 13
#define LOOK_FOR_BONDS 14

#define BAD_STATE -2

#define ALL_DONE TRUE
#define MORE_TO_READ FALSE

/* **************************************************************** */
/* local typedefs */

typedef struct {
char *string;
int state;
} PARSETABLE;

#define NPARSE(x) (sizeof(x)/sizeof(PARSETABLE))

typedef struct {
int nfiles;
char **fnames;
FILE *file;
int in_read;
int is_compressed;
int is_binary;
} READDATA;

typedef int (*PFI)();

typedef struct {
RECORD record_id;
PFI reader;
} READER;

/* **************************************************************** */
/* local prototypes */

PRIVATE int DoSomeReading(void);
PRIVATE int ReadSomeBinary(void);
PRIVATE int parser(char *token, PARSETABLE *table, int cnt);
PRIVATE int get_bounds(FILE *file, char *line);
PRIVATE int get_positions(FILE *file, char *line);
PRIVATE int get_time(FILE *file, char *line);
PRIVATE int get_bonds(FILE *file, char *line);
PRIVATE int copy_bonds(void);
PRIVATE void add_point(int index, int type, float x, float y, float z);
PRIVATE void add_bond(int type, int index1, int index2);
PRIVATE void NewData(void);
PRIVATE void ShowStatus(void);
PRIVATE char *RemoveNL(char *s);
PRIVATE int getline(FILE *file, char *line);
PRIVATE int get_float(char **s, float *f);
PRIVATE int get_int(char **s, int *i);
PRIVATE void ungetline(void);
PRIVATE int LineIsBlank(char *s);
PRIVATE void SortData(DATA *dptr);
PRIVATE int compare_atypes(POSITION *a, POSITION *b);
PRIVATE int compare_btypes(BOND *a, BOND *b);
PRIVATE int IsCompressed(char *s);
PRIVATE int IsBinary(char *s);
PRIVATE int TestBinary(FILE *f, int rewind);
PRIVATE FILE *GetCompressed(char *s);
PRIVATE FILE *OpenFile(char *s, int compressed, int binary);
PRIVATE READER *GetReader(RECORD record_id);
PRIVATE int ReadTime(FILE *f, LENGTH length);
PRIVATE int ReadBound(FILE *f, LENGTH length);
PRIVATE int ReadPosition(FILE *f, LENGTH length);
PRIVATE int ReadBond(FILE *f, LENGTH length);
PRIVATE int CopyBond(FILE *f, LENGTH length);
PRIVATE int ReadRecordHeader(FILE *f, RECORD *record, LENGTH *length);

/* **************************************************************** */
/* local data */

/* include last 3 out-of-date item names in PARSETABLE for compatability */

static PARSETABLE parse_table[] = {
{ "TIMESTEP", LOOK_FOR_TIME },
{ "BOX BOUNDS", LOOK_FOR_BOUNDS },
{ "ATOMS", LOOK_FOR_POSITIONS },
{ "BONDS", LOOK_FOR_BONDS },
{ "TIME", LOOK_FOR_TIME },
{ "BOUNDS", LOOK_FOR_BOUNDS },
{ "POSITIONS", LOOK_FOR_POSITIONS },
};

static DATA *current_data = (DATA *) NULL;
static int seen_time = 0;
static int npositions = 0;
static int nlines = 0;
static int nbonds = 0;
static int read_this_time = 0;

static READDATA ReadData = {
0, /* nfiles */
NULL, /* filenames */
NULL, /* file pointer */
0, /* not in read */
0, /* not compressed */
0, /* not binary */
};

static READER read_table[] = {
{ TimeID, ReadTime },
{ BoundID, ReadBound },
{ PositionID, ReadPosition },
{ BondID, ReadBond },
{ CopyBondID, CopyBond },
};

/* **************************************************************** */

void InitRead(int nfiles, char **fnames)
{
static char *Stdin = "stdin";

if (nfiles > 0) {
ReadData.nfiles = nfiles;
ReadData.fnames = fnames;
return;
}

if (isatty(fileno(stdin))) {
Usage();
exit(0);
}

ReadData.nfiles = 1;
ReadData.fnames = &Stdin;
ReadData.file = stdin;
ReadData.in_read = 1;
ReadData.is_binary = TestBinary(stdin, TRUE);

if (ReadData.is_binary)
fseek(stdin, 2*sizeof(INT4), SEEK_CUR); /* skip header */
}

Boolean ReadProc(XtPointer client_data)
{
char err_msg[512];
char *file_type;

if (ReadData.in_read) goto do_read;

next_file:

if (ReadData.nfiles <= 0) {
ShowStatus();
SortData(current_data);
return(ALL_DONE);
}

ReadData.is_compressed = FALSE;
ReadData.is_binary    = FALSE;

ReadData.is_compressed = IsCompressed(*ReadData.fnames);

if (ReadData.is_compressed) {
file_type = "compressed";
goto open_file;
}

ReadData.is_binary = IsBinary(*ReadData.fnames);
if (ReadData.is_binary) {
file_type = "binary";
goto open_file;
}

file_type = "ascii";
goto open_file;

open_file:

ReadData.file = OpenFile(*ReadData.fnames,
ReadData.is_compressed, ReadData.is_binary);
if (ReadData.file == (FILE *) NULL) {
sprintf(err_msg,
"Frames: %i  Positions: %i  Bonds: %i\n"
"Error: unable to open %s file \"%s\".\n"
"Read aborted.",
Common.ndata, npositions, nbonds,
file_type, *ReadData.fnames);
SetReadString(err_msg);
SortData(current_data);
return(ALL_DONE);
}

ReadData.in_read = 1;
nlines = 0;
ShowStatus();

do_read:

switch(DoSomeReading()) {
case END_OF_FILE:
if (ReadData.is_compressed)
pclose(ReadData.file);
else
if (strcmp("stdin",*ReadData.fnames))
fclose(ReadData.file);
ReadData.in_read = 0;
ReadData.nfiles--;
ReadData.fnames++;
goto next_file;
case ERROR:
SortData(current_data);
return(ALL_DONE);
case BEING_NICE:
break;
default:
fprintf(stderr,"Don't know how I got here: ReadProc.\n"

;
exit(0);
}

return(MORE_TO_READ);
}

PRIVATE int IsCompressed(char *s)
{
register char *t;

t = s + strlen(s) - 3;
if (t < s) return(FALSE);
return(!strcmp(t,".gz"

);
}

PRIVATE int IsBinary(char *s)
{
FILE *f;
int ok;

if ((FILE *) NULL == (f = fopen(s, "r"

)) return(FALSE);

ok = TestBinary(f, FALSE);
fclose(f);

return(ok);
}

PRIVATE int TestBinary(FILE *f, int rewind)
{
union {
INT4 magic;
char c[sizeof(INT4)];
} u;
int i;

if (1 != fread(&u.magic, sizeof(u.magic), 1, f)) return(FALSE);

if (rewind)
for(i = sizeof(u); i; i--)
ungetc(u.c[i-1], f);

return(u.magic == MagicNumber);
}

PRIVATE FILE *GetCompressed(char *name)
{
char cmd[256];

sprintf(cmd, "gunzip -c %s", name);
return(popen(cmd,"r"

);
}

PRIVATE FILE *OpenFile(char *name, int compressed, int binary)
{
FILE *f;

if (compressed) return(GetCompressed(name));

f = fopen(name, "r"

;
if (f == (FILE *) NULL) return(f);

if (binary) fseek(f, 2*sizeof(INT4), SEEK_CUR);

return(f);
}

PRIVATE int DoSomeReading(void)
{
static int state = LOOK_FOR_ITEM;
static char line[LINELEN];
static char token[LINELEN];
static char *t;
int ntries;
int newstate;
char err_msg[512];

if (ReadData.is_binary) return(ReadSomeBinary());

read_this_time = 0;

begin:

switch(state) {
case LOOK_FOR_ITEM:
ntries = 0;
while(1) {
ntries++;
if (ntries > 100) return(BEING_NICE);

if (!getline(ReadData.file, line))
return(END_OF_FILE);
t = strtok(line, WHITESPACE);
if (!t) continue;
if (strcmp(t, "ITEM:"

) continue;

t = strtok(NULL, WHITESPACE);
if (!t) continue;
sprintf(token,"%s",t);

t = strtok(NULL, WHITESPACE);
while (t != NULL) {
   sprintf(token,"%s %s",token,t);
   t = strtok(NULL, WHITESPACE);
}

newstate = parser(token,
   parse_table,NPARSE(parse_table));

if (newstate == BAD_STATE) continue;
state = newstate;
goto begin;
}
case LOOK_FOR_TIME:
if (!get_time(ReadData.file, line)) goto print_error;
state = LOOK_FOR_ITEM;
goto begin;
case LOOK_FOR_BOUNDS:
if (!get_bounds(ReadData.file, line)) goto print_error;
state = LOOK_FOR_ITEM;
goto begin;
case LOOK_FOR_POSITIONS:
case LOOK_FOR_BONDS:
switch((state == LOOK_FOR_POSITIONS) ?
get_positions(ReadData.file, line) :
get_bonds(ReadData.file, line)) {
case END_OF_FILE:
state = LOOK_FOR_ITEM;
return(END_OF_FILE);
case BEING_NICE:
return(BEING_NICE);
case LOOK_FOR_ITEM:
state = LOOK_FOR_ITEM;
return(BEING_NICE);
case ERROR:
default:
goto print_error;
}

case BAD_STATE:
default:
fprintf(stderr,"Error: read state corrupted: %i\n", state);
exit(0);
}

print_error:

sprintf(err_msg,"Frames: %i  Positions: %i  Bonds: %i\n"
"Error occurred at line %i\n"
"Processing ITEM: %s\n"
"Line = \"%s\"\n"
"Read aborted.",
Common.ndata, npositions, nbonds, nlines, token,
RemoveNL(line));

SetReadString(err_msg);

return(ERROR);

/* exit(0); */

}

/* **************************************************************** */

PRIVATE int parser(char *token, PARSETABLE *table, int cnt)
{
PARSETABLE *t;
int i;

for(i = cnt, t = table; i; i--, t++)
   if (strstr(token,t->string) == token)
      return t->state;
return(BAD_STATE);
}

/* **************************************************************** */

PRIVATE int get_bounds(FILE *file, char *line)
{
int i, n, changed;
char *t;
BOUND *b, *cb;

if (!current_data) NewData();

n = (Common.two_d) ? 2 : 3;

for(i = 0; i < n; i++){
if (!getline(file, line)) return(0);

t = line;

if (!get_float(&t, &(current_data->bounds.low)))
return(0);

if (!get_float(&t, &(current_data->bounds.high)))
return(0);
}

if (Common.two_d) {
current_data->bounds[2].low = -0.01;
current_data->bounds[2].high = 0.01;
}

changed = 0;
for(b=current_data->bounds,cb=Common.bounds,i=3; i;i--,b++,cb++){
if (b->low < cb->low) {
cb->low = b->low;
changed = 1;
}
if (b->high > cb->high) {
cb->high = b->high;
changed = 1;
}
}

if (changed) NewDataSetup();

return(1);
}

PRIVATE int get_positions(FILE *file, char *line)
{
char *t;
float x, y, z;
float          xlow,xhigh,ylow,yhigh,zlow,zhigh,dx,dy,dz;
int index, type;

if (!current_data) NewData();

if (Common.copy_bond) copy_bonds();

if (Common.remap || Common.scaleflag) {
   xlow = current_data->bounds[0].low;
   xhigh = current_data->bounds[0].high;
   dx = xhigh - xlow;
   ylow = current_data->bounds[1].low;
   yhigh = current_data->bounds[1].high;
   dy = yhigh - ylow;
   if (!Common.two_d) {
      zlow = current_data->bounds[2].low;
      zhigh = current_data->bounds[2].high;
      dz = zhigh - zlow;
   }
}

z = 0.0;

while(1) {

if (read_this_time++ > NREAD) return(BEING_NICE);

if (!getline(file, line)) return(END_OF_FILE);

t = line;

if (!get_int(&t, &index)){
ungetline();
return(LOOK_FOR_ITEM);
}

if (!get_int(&t, &type))  return(ERROR);

if (!get_float(&t, &x)) return(ERROR);
if (!get_float(&t, &y)) return(ERROR);

if (!Common.two_d)
if (!get_float(&t, &z)) return(ERROR);

if (type < 1 || type > Common.natomcolors) type = 1;

if (Common.remap) {
   if (x-xlow >= 0.0)
      x = fmod(x-xlow,dx) + xlow;
   else
      x = xhigh + fmod(x-xlow,dx);
   if (y-ylow >= 0.0)
      y = fmod(y-ylow,dy) + ylow;
   else
      y = yhigh + fmod(y-ylow,dy);
   if (!Common.two_d) {
      if (z-zlow >= 0.0)
      z = fmod(z-zlow,dz) + zlow;
      else
      z = zhigh + fmod(z-zlow,dz);
   }
}

if (Common.scaleflag) {
   x = xlow + x*dx;
   y = ylow + y*dy;
   if (!Common.two_d) z = zlow + z*dz;
}

add_point(index, type, x, y, z);

npositions++;

if ((nbonds + npositions) % NPRINT == 0) ShowStatus();

}

return(1);
}

PRIVATE int get_bonds(FILE *file, char *line)
{
char *t;
int type, index1, index2;

if (!current_data) NewData();

while(1) {

if (read_this_time++ > NREAD) return(BEING_NICE);

if (!getline(file, line)) return(END_OF_FILE);

t = line;

if (!get_int(&t, &type)){
ungetline();
return(LOOK_FOR_ITEM);
}

if (!get_int(&t, &index1)) return(ERROR);
if (!get_int(&t, &index2)) return(ERROR);

if (type < 1 || type > Common.nbondcolors) type = 1;

add_bond(type, index1, index2);

nbonds++;

if ((nbonds + npositions) % NPRINT == 0) ShowStatus();
}

return(1);
}

PRIVATE int get_time(FILE *file, char *line)
{
char *t;

if (!current_data || seen_time) NewData();
seen_time = 1;

if (!getline(file, line)) return(0);

t = line;

if (!get_float(&t, &(current_data->time))) return(0);

return(1);
}

PRIVATE int copy_bonds()
{
DATA *last_data;
int i;
BOND *b1, *b2;

if (Common.ndata < 2) return(0);

last_data = current_data-1;

current_data->nbonds = last_data->nbonds;
current_data->maxbonds = last_data->maxbonds;

current_data->bonds =
(BOND *) XtMalloc(current_data->maxbonds * sizeof(BOND));

b1 = current_data->bonds;
b2 = last_data->bonds;
for(i = current_data->nbonds; i ; i--, b1++, b2++)
*b1 = *b2;

return(1);
}

/* **************************************************************** */

PRIVATE char *RemoveNL(char *s)
{
register char *t;

if (!s) return(s);

if ((t = s + strlen(s) - 1) < s) return(s);
if (*t == '\n') *t = '\0';

return(s);
}

static int got_line = 0;

PRIVATE int getline(FILE *file, char *line)
{
int result;

if (got_line) {
got_line = 0;
return(1);
}

do {
nlines++;
result = (fgets(line, LINELEN, file) != NULL);
} while( result && LineIsBlank(line) );

return(result);
}

PRIVATE void ungetline(void)
{
got_line = 1;
}

PRIVATE int LineIsBlank(char *s)
{
register char *t;

t = s + strspn(s, WHITESPACE);
return( *t == '\0' );
}

PRIVATE int get_int(char **s, int *i)
{
register char *t;

t = *s + strspn(*s, SEPARATORS);
*i = strtol(t, s, 10);

return(t != *s);
}

PRIVATE int get_float(char **s, float *f)
{
register char *t;

t = *s + strspn(*s, SEPARATORS);
*f = strtod(t, s);

return(t != *s);
}

/* **************************************************************** */

PRIVATE void NewData(void)
{
int i;
DATA *last_data,*olddataptr;

olddataptr = Common.dataptr;
last_data = current_data;

if (Common.ndata >= Common.maxdata) { /* need to realloc */
Common.maxdata += 256;
Common.dataptr = (DATA *)
   XtMalloc(Common.maxdata * sizeof(DATA));
memcpy(Common.dataptr,olddataptr,Common.ndata*sizeof(DATA));
}

current_data = Common.dataptr + Common.ndata;
Common.ndata++;

current_data->natypes =
(INT4 *) XtMalloc(Common.natomcolors * sizeof(INT4));

for(i = 0; i < Common.natomcolors; i++)
current_data->natypes = 0;

current_data->nbtypes =
(INT4 *) XtMalloc(Common.nbondcolors * sizeof(INT4));

for(i = 0; i < Common.nbondcolors; i++)
current_data->nbtypes = 0;

if (Common.ndata > 1) {
current_data->time = last_data->time;

for(i = 0; i < 3; i++)
current_data->bounds = last_data->bounds;

current_data->maxatoms = last_data->natoms;
current_data->positions = (POSITION *)
XtMalloc(last_data->natoms * sizeof(POSITION));

current_data->natoms = 0;

current_data->maxbonds = last_data->nbonds;
current_data->bonds = (BOND *)
XtMalloc(last_data->nbonds * sizeof(BOND));

current_data->nbonds = 0;

SortData(last_data);
}
else {
current_data->time = 0.0;

for(i = 0; i < 3; i++) {
current_data->bounds.low = -1.0;
current_data->bounds.high = 1.0;
}

current_data->natoms = 0;
current_data->positions = NULL;
current_data->maxatoms = 0;

current_data->nbonds = 0;
current_data->bonds = NULL;
current_data->maxbonds = 0;
}

if (olddataptr != Common.dataptr) XtFree((char *) olddataptr);
}

PRIVATE void add_point(int index, int type, float x, float y, float z)
{
POSITION *p;

if (current_data->natoms >= current_data->maxatoms) {
current_data->maxatoms += 16;
current_data->positions = (POSITION *)
XtRealloc((char *) current_data->positions,
   current_data->maxatoms * sizeof(POSITION));
}

p = &(current_data->positions[current_data->natoms]);

p->index = index;
p->type  = type;
p->x    = x;
p->y    = y;
p->z    = z;

current_data->natoms++;
}

PRIVATE void add_bond(int type, int index1, int index2)
{
BOND *b;

if (current_data->nbonds >= current_data->maxbonds) {
current_data->maxbonds += 16;
current_data->bonds = (BOND *)
XtRealloc((char *) current_data->bonds,
current_data->maxbonds * sizeof(BOND));
}

b = &(current_data->bonds[current_data->nbonds]);

b->type = type;
b->index1 = index1;
b->index2 = index2;
b->atom1  = NULL;
b->atom2  = NULL;

current_data->nbonds++;
}

PRIVATE void ShowStatus(void)
{
static char buffer[256];

if (ReadData.in_read)
sprintf(buffer, "Reading file: %s\n"
"Frames: %i  Positions: %i  Bonds: %i",
*ReadData.fnames, Common.ndata, npositions,
nbonds);
else
sprintf(buffer, "Reading done.\n"
"Frames: %i  Positions: %i  Bonds %i",
Common.ndata, npositions, nbonds);

SetReadString(buffer);
}

/* **************************************************************** */

PRIVATE void SortData(DATA *dptr)
{
POSITION *p, **p_by_index, **pp;
register int i, j;
int maxindex, minindex, nindex, n;
register BOND *b, *b2;
float bond_length, shortest, dx, dy, dz;

/* add hpsort in place of standard C qsort, which is very slow
         when atoms or bonds are already in order (N^2 instead of NlnN)
         calling syntax does not change except for first argument
         becomes arg-1, qsort -> hpsort in 2 places
*/
void hpsort(POSITION *, int, int, int (*)(POSITION *, POSITION *));

if (!dptr) return;

/* sort by type */

hpsort((dptr->positions)-1, dptr->natoms, sizeof(POSITION),
compare_atypes);

/* find out how many of each type */

for(i = dptr->natoms, p = dptr->positions; i ;i--, p++)
dptr->natypes[p->type-1]++;

if (dptr->nbonds < 1) return;

/* find max, min indicies */

minindex = 1000000000;
maxindex = -minindex;

for(i = dptr->natoms, p = dptr->positions; i; i--, p++) {
if (p->index > maxindex) maxindex = p->index;
if (p->index < minindex) minindex = p->index;
}

nindex = maxindex - minindex + 1;

if (nindex < 0) {
dptr->nbonds = 0;
return;
}


if (nindex < 1000000) {

p_by_index = (POSITION **) XtMalloc(nindex*sizeof(POSITION *));

for(pp = p_by_index, i = nindex; i; i--, pp++)
*pp = (POSITION *) NULL;

for(p = dptr->positions, i = dptr->natoms; i; i--, p++){
pp = p_by_index + p->index - minindex;
if (*pp != (POSITION *) NULL) {
fprintf(stderr,
"Error: atom %i has more than one position at time %g.\n",
p->index, dptr->time);
exit(EXIT_FAILURE);
}
*pp = p;
}

for(b = dptr->bonds, i = dptr->nbonds; i ; i--, b++) {
b->atom1 = p_by_index[b->index1 - minindex];
b->atom2 = p_by_index[b->index2 - minindex];
if (b->atom1 == (POSITION *) NULL) {
fprintf(stderr,
"Error: atom %d has no position at time %g.\n",
b->index1, dptr->time);
exit(EXIT_FAILURE);
}
if (b->atom2 == (POSITION *) NULL) {
fprintf(stderr,
"Error: atom %d has no position at time %g.\n",
b->index2, dptr->time);
exit(EXIT_FAILURE);
}
}

XtFree((char *) p_by_index);
}
else {
for(b = dptr->bonds, i = dptr->nbonds; i; i--, b++) {
for(p = dptr->positions, j = dptr->natoms; j; j--, p++)
if (b->index1 == p->index) {
b->atom1 = p;
break;
}
if (j < 1) {
fprintf(stderr,
"Error: atom %i has no position at time %g.\n",
b->index1, dptr->time);
exit(EXIT_FAILURE);
}
for(p = dptr->positions, j = dptr->natoms; j; j--, p++)
if (b->index2 == p->index) {
b->atom2 = p;
break;
}
if (j < 1) {
fprintf(stderr,
"Error: atom %i has no position at time %g.\n",
b->index2, dptr->time);
exit(EXIT_FAILURE);
}
}
}

/* throw out bonds longer than half the shortest cell size */
      /* only do if periodic-bond switch is set */

if (Common.pbc_bond) {

   n = (Common.two_d) ? 2 : 3;

   shortest = 1e30;
   for(i = 0; i < n; i++){
      bond_length = dptr->bounds.high - dptr->bounds.low;
      if (bond_length < shortest) shortest = bond_length;
   }

   shortest *= 0.5;
   shortest *= shortest;

   b = dptr->bonds;
   b2 = b;
   for(i = dptr->nbonds; i; i--, b++) {
      dx = b->atom1->x - b->atom2->x;
      dy = b->atom1->y - b->atom2->y;
      dz = b->atom1->z - b->atom2->z;
      bond_length = dx*dx + dy*dy + dz*dz;
      if (bond_length < shortest) {
      if (b2 != b) *b2 = *b;
      b2++;
      }
   }

   dptr->nbonds -= b - b2;

}

/* sort by type */

hpsort((dptr->bonds)-1, dptr->nbonds, sizeof(BOND),
compare_btypes);

/* find out how many of each type */

for(b = dptr->bonds, i = dptr->nbonds; i; i--, b++)
dptr->nbtypes[b->type-1]++;
}

PRIVATE int compare_atypes(POSITION *a, POSITION *b)
{
if (a->type  > b->type) return(1);
if (a->type == b->type) return(0);
if (a->type  < b->type) return(-1);
}

PRIVATE int compare_btypes(BOND *a, BOND *b)
{
if (a->type  > b->type) return(1);
if (a->type == b->type) return(0);
if (a->type  < b->type) return(-1);
}

/* routine to print out all data for debugging */

#if 0

print_them(void)
{
int i;

for(i = 0; i < Common.ndata; i++)
print_data(Common.dataptr);
}

print_data(DATA *data)
{
int i;
POSITION *p;

fprintf(stderr,"Time: %f\n", data->time);

for(i = 0; i < 3; i++)
fprintf(stderr,"Bounds %i: %f %f\n", i, data->bounds.low,
data->bounds.high);

for(i = 0; i < data->natoms; i++) {
p = &(data->positions);
fprintf(stderr,"Atom: %i %i %f %f %f\n",
p->index, p->type, p->x, p->y, p->z);
}
}

#endif

/* **************************************************************** */

PRIVATE int ReadSomeBinary(void)
{
RECORD record_id;
LENGTH length;
READER *r;
char err_msg[256];
int state;
int old_positions, old_bonds;

old_positions = npositions;
old_bonds = nbonds;

while(1) {
if (!ReadRecordHeader(ReadData.file, &record_id, &length))
return(END_OF_FILE);

r = GetReader(record_id);
if (r == (READER *) NULL) { /* dont recognize */
fseek(ReadData.file, length, SEEK_CUR);
continue;
}

switch(state = (*r->reader)(ReadData.file, length)) {
case BEING_NICE:
if (old_positions + old_bonds + NBREAD >
nbonds + npositions)
continue;
return(state);
case END_OF_FILE:
return(state);
case READ_OK:
continue;
case ERROR:
default:
sprintf(err_msg,"Frames: %i  Positions: %i  Bonds: %i\n"
"Error occurred during binary read.\n"
"Read aborted.",
Common.ndata, npositions, nbonds);
SetReadString(err_msg);
return(ERROR);
}
}
}

PRIVATE READER *GetReader(RECORD record_id)
{
register int i;
register READER *r;

i = sizeof(read_table)/sizeof(read_table[0]);
for(r = read_table; i; i--, r++)
if (r->record_id == record_id) return(r);

return((READER *) NULL);
}

PRIVATE int ReadRecordHeader(FILE *f, RECORD *record, LENGTH *length)
{
if (1 != fread(record, sizeof(*record), 1, f)) return(FALSE);
if (1 != fread(length, sizeof(*length), 1, f)) return(FALSE);

return(TRUE);
}

/*ARGSUSED*/
PRIVATE int ReadBound(FILE *file, LENGTH length)
{
int i, changed;
BOUND *b, *cb;

if (!current_data) NewData();

for(b = current_data->bounds, i = 3; i; i--, b++){
if (1 != fread(&(b->low), sizeof(b->low), 1, file))
return(ERROR);
if (1 != fread(&(b->high), sizeof(b->high), 1, file))
return(ERROR);
}

changed = 0;
for(b=current_data->bounds,cb=Common.bounds,i=3; i;i--,b++,cb++){
if (b->low < cb->low) {
cb->low = b->low;
changed = 1;
}
if (b->high > cb->high) {
cb->high = b->high;
changed = 1;
}
}

if (changed) NewDataSetup();

return(READ_OK);
}

PRIVATE int ReadPosition(FILE *file, LENGTH length)
{
POSITION *p;
int n;
int i;

if (!current_data) NewData();

n = length / (sizeof(p->index) + sizeof(p->type) + 3*sizeof(p->x));

if (current_data->maxatoms < n) {
free(current_data->positions);
current_data->maxatoms = n;
current_data->positions =
(POSITION *) XtMalloc(n * sizeof(POSITION));
}

current_data->natoms = 0;
p = current_data->positions;
i = 0;

for(; i < n; i++, p++) {
if (1 != fread(&(p->index), sizeof(p->index), 1, file))
return(ERROR);
if (1 != fread(&(p->type),  sizeof(p->type),  1, file))
return(ERROR);
if (1 != fread(&(p->x),    sizeof(p->x),    1, file))
return(ERROR);
if (1 != fread(&(p->y),    sizeof(p->y),    1, file))
return(ERROR);
if (1 != fread(&(p->z),    sizeof(p->z),    1, file))
return(ERROR);

if (p->type < 1 || p->type > Common.natomcolors)
p->type = 1;

npositions++;
current_data->natoms++;

if ((npositions + nbonds)% NPRINT == 0) ShowStatus();
}

return(BEING_NICE);
}

PRIVATE int ReadBond(FILE *file, LENGTH length)
{
BOND *b;
int n;
int i;

if (!current_data) NewData();

n = length / (sizeof(b->type) + sizeof(b->index1) + sizeof(b->index2));

if (current_data->maxbonds < n) {
free(current_data->bonds);
current_data->maxbonds = n;
current_data->bonds =
(BOND *) XtMalloc(n * sizeof(BOND));
}

current_data->nbonds = 0;
b = current_data->bonds;
i = 0;

for(; i < n; i++, b++) {
if (1 != fread(&(b->type), sizeof(b->type), 1, file))
return(ERROR);
if (1 != fread(&(b->index1), sizeof(b->index1),  1, file))
return(ERROR);
if (1 != fread(&(b->index2), sizeof(b->index2),  1, file))
return(ERROR);

if (b->type < 1 || b->type > Common.nbondcolors)
b->type = 1;

nbonds++;
current_data->nbonds++;

if ((npositions + nbonds)% NPRINT == 0) ShowStatus();
}

return(BEING_NICE);
}

/*ARGSUSED*/
PRIVATE int CopyBond(FILE *file, LENGTH length)
{
return( (copy_bonds()) ? READ_OK : ERROR );
}

/*ARGSUSED*/
PRIVATE int ReadTime(FILE *file, LENGTH length)
{
if (!current_data || seen_time) NewData();
seen_time = 1;

if (1 != fread(&(current_data->time), sizeof(current_data->time),
1, file))
return(ERROR);
return(READ_OK);
}

這是我的read.c文件，你看看和你的有什么區(qū)別吧，呵呵，我沒(méi)有仔細(xì)研究過(guò)xmovie, 我都用vmd的， xmovie能辦到的vmd都可以，而且使用更方便，更美觀，所以你如果還是弄不好xmovie，那就別糾結(jié)了，換vmd吧

贊一下

回復(fù)此樓

4樓2012-03-09 03:00:23

已閱回復(fù)此樓關(guān)注TA 給TA發(fā)消息送TA紅花 TA的回帖

相關(guān)版塊跳轉(zhuǎn) 我要訂閱樓主 xjw040 的主題更新

返回列表

普通表情龍兔虎貓

最具人氣熱帖推薦 [查看全部]		作者	回/看	最后發(fā)表

[考研] 一志愿南京大學(xué)，080500材料科學(xué)與工程，調(diào)劑 +4	Jy? 2026-03-16	4/200	2026-03-17 11:02 by gaoqiong
[考研] 285化工學(xué)碩求調(diào)劑（081700） +9	柴郡貓_ 2026-03-12	9/450	2026-03-17 10:18 by Sammy2
[考研] 考研調(diào)劑 +3	淇ya_~ 2026-03-17	5/250	2026-03-17 09:25 by Winj1e
[考研] 283求調(diào)劑 +3	聽(tīng)風(fēng)就是雨； 2026-03-16	3/150	2026-03-17 07:41 by 熱情沙漠
[考研] 341求調(diào)劑 +5	搗蛋豬豬 2026-03-11	5/250	2026-03-17 06:56 by Muziwl
[基金申請(qǐng)] 國(guó)自科面上基金字體 +6	iwuli 2026-03-12	7/350	2026-03-16 21:18 by sculhf
[考研] 286求調(diào)劑 +3	lemonzzn 2026-03-16	5/250	2026-03-16 20:43 by lemonzzn
[考研] 考研化學(xué)學(xué)碩調(diào)劑，一志愿985 +3	張vvvv 2026-03-15	5/250	2026-03-16 20:25 by 張vvvv
[考研] 環(huán)境工程調(diào)劑 +6	大可digkids 2026-03-16	6/300	2026-03-16 17:16 by barlinike
[考研] 308求調(diào)劑 +3	是Lupa啊 2026-03-16	3/150	2026-03-16 10:07 by 求調(diào)劑zz
[考研] 0856專碩279求調(diào)劑 +5	加油加油！? 2026-03-15	5/250	2026-03-15 11:58 by 2020015
[考研] 本科南京大學(xué)一志愿川大藥學(xué)327 +3	麥田耕者 2026-03-14	3/150	2026-03-14 20:04 by 外星文明
[考研] 材料與化工 323 英一+數(shù)二+物化，一志愿：哈工大本人本科雙一流 +4	自由的_飛翔 2026-03-13	5/250	2026-03-14 19:39 by hmn_wj
[基金申請(qǐng)] 現(xiàn)在如何回避去年的某一個(gè)專家，不知道名字 +3	zk200107 2026-03-12	6/300	2026-03-14 17:13 by zk200107
[考研] 求材料調(diào)劑 085600英一數(shù)二總分302 前三科235 精通機(jī)器學(xué)習(xí) 一志愿哈工大 +4	林yaxin 2026-03-12	4/200	2026-03-13 22:04 by 星空星月
[考研] 求調(diào)劑 +7	18880831720 2026-03-11	7/350	2026-03-13 16:10 by JourneyLucky
[考研] 一志愿211化學(xué)學(xué)碩310分求調(diào)劑 +8	努力奮斗112 2026-03-12	9/450	2026-03-13 15:41 by JourneyLucky
[考研] 085600材料與化工 309分請(qǐng)求調(diào)劑 +7	dtdxzxx 2026-03-12	8/400	2026-03-13 14:43 by jxchenghu
[考研] 274求調(diào)劑0856材料化工 +12	z2839474511 2026-03-11	13/650	2026-03-13 10:39 by peike
[考研] 321求調(diào)劑（食品/專碩） +3	xc321 2026-03-12	6/300	2026-03-13 08:45 by xc321