From da20f7966ecf703c4aa46ddaf12190a6f96623d0 Mon Sep 17 00:00:00 2001 From: afonsofrancof Date: Sun, 15 Oct 2023 00:56:00 +0100 Subject: [PATCH] Started work on Potential Unrolled powers removed duplicate array access on k for tried starting using omp parallel --- .clang-format | 5 + Makefile | 29 ++ analysis/14-10__16_15_42.dot | 15 + analysis/14-10__16_15_42.txt | 204 ++++++++++ analysis/14-10__23_34_05.dot | 14 + analysis/14-10__23_34_05.txt | 178 +++++++++ analysis/14-10__23_38_12.dot | 14 + analysis/14-10__23_38_12.txt | 183 +++++++++ analysis/15-10__00_20_24.dot | 14 + analysis/15-10__00_20_24.txt | 178 +++++++++ analysis/15-10__00_29_40.dot | 15 + analysis/15-10__00_29_40.txt | 178 +++++++++ analysis/15-10__00_31_08.txt | 178 +++++++++ analysis/15-10__00_31_31.txt | 178 +++++++++ analysis/15-10__00_35_14.txt | 178 +++++++++ analysis/15-10__00_35_37.txt | 178 +++++++++ analysis/15-10__00_36_25.txt | 183 +++++++++ analysis/15-10__00_39_51.txt | 178 +++++++++ analysis/15-10__00_44_19.txt | 178 +++++++++ analysis/15-10__00_47_57.txt | 0 analysis/15-10__00_48_05.txt | 178 +++++++++ analysis/15-10__00_49_03.txt | 183 +++++++++ analysis/15-10__00_50_01.txt | 178 +++++++++ analysis/15-10__00_51_34.txt | 178 +++++++++ analysis/15-10__00_52_18.txt | 179 +++++++++ analysis/15-10__00_53_56.txt | 178 +++++++++ input/inputdata.txt | 5 + out/MD | Bin 0 -> 25872 bytes src/.DS_Store | Bin 0 -> 6148 bytes src/MD-original.cpp | 702 ++++++++++++++++++++++++++++++++++ src/MD.cpp | 718 +++++++++++++++++++++++++++++++++++ 31 files changed, 4777 insertions(+) create mode 100644 .clang-format create mode 100644 Makefile create mode 100644 analysis/14-10__16_15_42.dot create mode 100644 analysis/14-10__16_15_42.txt create mode 100644 analysis/14-10__23_34_05.dot create mode 100644 analysis/14-10__23_34_05.txt create mode 100644 analysis/14-10__23_38_12.dot create mode 100644 analysis/14-10__23_38_12.txt create mode 100644 analysis/15-10__00_20_24.dot create mode 100644 analysis/15-10__00_20_24.txt create mode 100644 analysis/15-10__00_29_40.dot create mode 100644 analysis/15-10__00_29_40.txt create mode 100644 analysis/15-10__00_31_08.txt create mode 100644 analysis/15-10__00_31_31.txt create mode 100644 analysis/15-10__00_35_14.txt create mode 100644 analysis/15-10__00_35_37.txt create mode 100644 analysis/15-10__00_36_25.txt create mode 100644 analysis/15-10__00_39_51.txt create mode 100644 analysis/15-10__00_44_19.txt create mode 100644 analysis/15-10__00_47_57.txt create mode 100644 analysis/15-10__00_48_05.txt create mode 100644 analysis/15-10__00_49_03.txt create mode 100644 analysis/15-10__00_50_01.txt create mode 100644 analysis/15-10__00_51_34.txt create mode 100644 analysis/15-10__00_52_18.txt create mode 100644 analysis/15-10__00_53_56.txt create mode 100644 input/inputdata.txt create mode 100755 out/MD create mode 100644 src/.DS_Store create mode 100644 src/MD-original.cpp create mode 100644 src/MD.cpp diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..19ae969 --- /dev/null +++ b/.clang-format @@ -0,0 +1,5 @@ +BasedOnStyle: GNU +IndentWidth: 4 +TabWidth: 4 +UseTab: Always +BreakBeforeBraces: Attach diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..6f71bf2 --- /dev/null +++ b/Makefile @@ -0,0 +1,29 @@ +CC = gcc +SRC = src/ +CFLAGS = # none +ts := $(shell /usr/bin/date "+%d-%m__%H_%M_%S") + +.DEFAULT_GOAL = MD + +MD: $(SRC)/MD.cpp + $(CC) $(CFLAGS) $(SRC)MD.cpp -lm -O2 -fopenmp -pg -o ./out/MD + +MDorig: $(SRC)/MD-original.cpp + $(CC) $(CFLAGS) $(SRC)MD-original.cpp -lm -O2 -fopenmp -pg -o ./out/MD-original + +clean: + rm ./out/* gmon.out + +run: + ./out/MD < input/inputdata.txt + +runorig: + ./out/MD-original < input/inputdata.txt + +gprof: + gprof out/MD gmon.out > analysis/$(ts).txt + +gproforig: + gprof out/MD-original gmon.out > analysis/$(ts).txt + +runfull: clean MD run gprof diff --git a/analysis/14-10__16_15_42.dot b/analysis/14-10__16_15_42.dot new file mode 100644 index 0000000..9068bfc --- /dev/null +++ b/analysis/14-10__16_15_42.dot @@ -0,0 +1,15 @@ +digraph { + graph [fontname=Arial, nodesep=0.125, ranksep=0.25]; + node [fontcolor=white, fontname=Arial, height=0, shape=box, style=filled, width=0]; + edge [fontname=Arial]; + 1 [color="#fe0500", fontcolor="#ffffff", fontsize="10.00", label="main\n99.56%\n(0.00%)"]; + 1 -> 2 [arrowsize="0.74", color="#2abc09", fontcolor="#2abc09", fontsize="10.00", label="54.56%\n201×", labeldistance="2.18", penwidth="2.18"]; + 1 -> 3 [arrowsize="0.35", color="#0d0e73", fontcolor="#0d0e73", fontsize="10.00", label="0.22%\n1×", labeldistance="0.50", penwidth="0.50"]; + 1 -> 4 [arrowsize="0.67", color="#0aae2c", fontcolor="#0aae2c", fontsize="10.00", label="44.79%\n201×", labeldistance="1.79", penwidth="1.79"]; + 2 [color="#2abc09", fontcolor="#ffffff", fontsize="10.00", label="Potential()\n54.56%\n(54.56%)\n201×"]; + 3 [color="#0aaf2b", fontcolor="#ffffff", fontsize="10.00", label="computeAccelerations()\n45.01%\n(35.43%)\n202×"]; + 3 -> 5 [arrowsize="0.35", color="#0d397f", fontcolor="#0d397f", fontsize="10.00", label="9.58%\n942014880×", labeldistance="0.50", penwidth="0.50"]; + 4 [color="#0aae2c", fontcolor="#ffffff", fontsize="10.00", label="VelocityVerlet(double, int, _IO_FILE*)\n44.79%\n(0.00%)\n201×"]; + 4 -> 3 [arrowsize="0.67", color="#0aae2c", fontcolor="#0aae2c", fontsize="10.00", label="44.79%\n201×", labeldistance="1.79", penwidth="1.79"]; + 5 [color="#0d397f", fontcolor="#ffffff", fontsize="10.00", label="__gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(double, int)\n9.58%\n(9.58%)\n942014880×"]; +} diff --git a/analysis/14-10__16_15_42.txt b/analysis/14-10__16_15_42.txt new file mode 100644 index 0000000..7c49400 --- /dev/null +++ b/analysis/14-10__16_15_42.txt @@ -0,0 +1,204 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 54.61 15.03 15.03 201 74.79 74.79 Potential() + 35.45 24.79 9.76 202 48.31 61.39 computeAccelerations() + 9.60 27.43 2.64 942014880 0.00 0.00 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(double, int) + 0.44 27.55 0.12 _init + 0.00 27.55 0.00 6480 0.00 0.00 gaussdist() + 0.00 27.55 0.00 201 0.00 61.39 VelocityVerlet(double, int, _IO_FILE*) + 0.00 27.55 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 27.55 0.00 201 0.00 0.00 Kinetic() + 0.00 27.55 0.00 1 0.00 0.00 initialize() + 0.00 27.55 0.00 1 0.00 0.00 initializeVelocities() + 0.00 27.55 0.00 1 0.00 0.00 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(int, double) + 0.00 27.55 0.00 1 0.00 0.00 __gnu_cxx::__enable_if::__value, double>::__type std::floor(int) + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.04% of 27.55 seconds + +index % time self children called name + +[1] 99.6 0.00 27.43 main [1] + 15.03 0.00 201/201 Potential() [2] + 0.00 12.34 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.05 0.01 1/202 computeAccelerations() [3] + 0.00 0.00 201/201 MeanSquaredVelocity() [11] + 0.00 0.00 201/201 Kinetic() [12] + 0.00 0.00 1/1 initialize() [13] + 0.00 0.00 1/1 __gnu_cxx::__enable_if::__value, double>::__type std::floor(int) [16] +----------------------------------------------- + 15.03 0.00 201/201 main [1] +[2] 54.6 15.03 0.00 201 Potential() [2] +----------------------------------------------- + 0.05 0.01 1/202 main [1] + 9.71 2.63 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[3] 45.0 9.76 2.64 202 computeAccelerations() [3] + 2.64 0.00 942014880/942014880 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(double, int) [5] +----------------------------------------------- + 0.00 12.34 201/201 main [1] +[4] 44.8 0.00 12.34 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 9.71 2.63 201/202 computeAccelerations() [3] +----------------------------------------------- + 2.64 0.00 942014880/942014880 computeAccelerations() [3] +[5] 9.6 2.64 0.00 942014880 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(double, int) [5] +----------------------------------------------- + +[6] 0.4 0.12 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 6480/6480 initializeVelocities() [14] +[10] 0.0 0.00 0.00 6480 gaussdist() [10] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[11] 0.0 0.00 0.00 201 MeanSquaredVelocity() [11] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[12] 0.0 0.00 0.00 201 Kinetic() [12] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[13] 0.0 0.00 0.00 1 initialize() [13] + 0.00 0.00 1/1 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(int, double) [15] + 0.00 0.00 1/1 initializeVelocities() [14] +----------------------------------------------- + 0.00 0.00 1/1 initialize() [13] +[14] 0.0 0.00 0.00 1 initializeVelocities() [14] + 0.00 0.00 6480/6480 gaussdist() [10] +----------------------------------------------- + 0.00 0.00 1/1 initialize() [13] +[15] 0.0 0.00 0.00 1 __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(int, double) [15] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[16] 0.0 0.00 0.00 1 __gnu_cxx::__enable_if::__value, double>::__type std::floor(int) [16] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [13] initialize() [14] initializeVelocities() [5] __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(double, int) + [4] VelocityVerlet(double, int, _IO_FILE*) [12] Kinetic() [15] __gnu_cxx::__promote_2::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0))), std::__is_integer::__value>::__type)(0))+((__gnu_cxx::__promote_2::__value>::__type)(0)))>::__value>::__type std::pow(int, double) + [11] MeanSquaredVelocity() [2] Potential() [16] __gnu_cxx::__enable_if::__value, double>::__type std::floor(int) + [3] computeAccelerations() [10] gaussdist() [6] _init diff --git a/analysis/14-10__23_34_05.dot b/analysis/14-10__23_34_05.dot new file mode 100644 index 0000000..5c7f5f1 --- /dev/null +++ b/analysis/14-10__23_34_05.dot @@ -0,0 +1,14 @@ +digraph { + graph [fontname=Arial, nodesep=0.125, ranksep=0.25]; + node [fontcolor=white, fontname=Arial, height=0, shape=box, style=filled, width=0]; + edge [fontname=Arial]; + 1 [color="#ff0100", fontcolor="#ffffff", fontsize="10.00", label="main\n99.88%\n(0.00%)"]; + 1 -> 3 [arrowsize="0.98", color="#f82f01", fontcolor="#f82f01", fontsize="10.00", label="95.37%\n1×", labeldistance="3.81", penwidth="3.81"]; + 1 -> 5 [arrowsize="0.35", color="#0d2078", fontcolor="#0d2078", fontsize="10.00", label="4.47%\n201×", labeldistance="0.50", penwidth="0.50"]; + 2 [color="#f82f01", fontcolor="#ffffff", fontsize="10.00", label="_dl_relocate_static_pie\n95.37%\n(95.37%)\n3240×"]; + 3 [color="#f82f01", fontcolor="#ffffff", fontsize="10.00", label="initializeVelocities()\n95.37%\n(0.00%)\n1×"]; + 3 -> 2 [arrowsize="0.98", color="#f82f01", fontcolor="#f82f01", fontsize="10.00", label="95.37%\n3240×", labeldistance="3.81", penwidth="3.81"]; + 4 [color="#0d2078", fontcolor="#ffffff", fontsize="10.00", label="computeAccelerations()\n4.49%\n(4.49%)\n202×"]; + 5 [color="#0d2078", fontcolor="#ffffff", fontsize="10.00", label="VelocityVerlet(double, int, _IO_FILE*)\n4.47%\n(0.00%)\n201×"]; + 5 -> 4 [arrowsize="0.35", color="#0d2078", fontcolor="#0d2078", fontsize="10.00", label="4.47%\n201×", labeldistance="0.50", penwidth="0.50"]; +} diff --git a/analysis/14-10__23_34_05.txt b/analysis/14-10__23_34_05.txt new file mode 100644 index 0000000..ed745c1 --- /dev/null +++ b/analysis/14-10__23_34_05.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 95.46 33.14 33.14 3240 0.01 0.01 _dl_relocate_static_pie + 4.50 34.71 1.56 202 0.01 0.01 computeAccelerations() + 0.12 34.75 0.04 _init + 0.03 34.76 0.01 201 0.00 0.00 MeanSquaredVelocity() + 0.00 34.76 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 34.76 0.00 1 0.00 0.00 initialize() + 0.00 34.76 0.00 1 0.00 33.14 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.03% of 34.76 seconds + +index % time self children called name + +[1] 99.9 0.00 34.72 main [1] + 0.00 33.14 1/1 initializeVelocities() [3] + 0.00 1.55 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 201/201 MeanSquaredVelocity() [7] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 33.14 0.00 3240/3240 initializeVelocities() [3] +[2] 95.4 33.14 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 33.14 1/1 main [1] +[3] 95.4 0.00 33.14 1 initializeVelocities() [3] + 33.14 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.55 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 4.5 1.56 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.55 201/201 main [1] +[5] 4.5 0.00 1.55 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.55 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.1 0.04 0.00 _init [6] +----------------------------------------------- + 0.01 0.00 201/201 main [1] +[7] 0.0 0.01 0.00 201 MeanSquaredVelocity() [7] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [7] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/14-10__23_38_12.dot b/analysis/14-10__23_38_12.dot new file mode 100644 index 0000000..5627672 --- /dev/null +++ b/analysis/14-10__23_38_12.dot @@ -0,0 +1,14 @@ +digraph { + graph [fontname=Arial, nodesep=0.125, ranksep=0.25]; + node [fontcolor=white, fontname=Arial, height=0, shape=box, style=filled, width=0]; + edge [fontname=Arial]; + 1 [color="#f53f02", fontcolor="#ffffff", fontsize="10.00", label="main\n93.67%\n(0.00%)"]; + 1 -> 2 [arrowsize="0.35", color="#0d0e73", fontcolor="#0d0e73", fontsize="10.00", label="0.25%\n1×", labeldistance="0.50", penwidth="0.50"]; + 1 -> 3 [arrowsize="0.71", color="#10b709", fontcolor="#10b709", fontsize="10.00", label="51.01%\n201×", labeldistance="2.04", penwidth="2.04"]; + 1 -> 4 [arrowsize="0.65", color="#0aab3b", fontcolor="#0aab3b", fontsize="10.00", label="42.41%\n201×", labeldistance="1.70", penwidth="1.70"]; + 2 [color="#12b709", fontcolor="#ffffff", fontsize="10.00", label="computeAccelerations()\n51.27%\n(51.27%)\n202×"]; + 3 [color="#10b709", fontcolor="#ffffff", fontsize="10.00", label="VelocityVerlet(double, int, _IO_FILE*)\n51.01%\n(0.00%)\n201×"]; + 3 -> 2 [arrowsize="0.71", color="#10b709", fontcolor="#10b709", fontsize="10.00", label="51.01%\n201×", labeldistance="2.04", penwidth="2.04"]; + 4 [color="#0aab3b", fontcolor="#ffffff", fontsize="10.00", label="Potential()\n42.41%\n(42.41%)\n201×"]; + 5 [color="#0d297b", fontcolor="#ffffff", fontsize="10.00", label="_init\n6.33%\n(6.33%)"]; +} diff --git a/analysis/14-10__23_38_12.txt b/analysis/14-10__23_38_12.txt new file mode 100644 index 0000000..69c4fe1 --- /dev/null +++ b/analysis/14-10__23_38_12.txt @@ -0,0 +1,183 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 51.16 1.62 1.62 202 8.00 8.00 computeAccelerations() + 42.45 2.96 1.34 201 6.67 6.67 Potential() + 6.34 3.16 0.20 _init + 0.00 3.16 0.00 3240 0.00 0.00 _dl_relocate_static_pie + 0.00 3.16 0.00 201 0.00 8.00 VelocityVerlet(double, int, _IO_FILE*) + 0.00 3.16 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 3.16 0.00 1 0.00 0.00 initialize() + 0.00 3.16 0.00 1 0.00 0.00 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.32% of 3.16 seconds + +index % time self children called name + +[1] 93.7 0.00 2.96 main [1] + 0.00 1.61 201/201 VelocityVerlet(double, int, _IO_FILE*) [3] + 1.34 0.00 201/201 Potential() [4] + 0.01 0.00 1/202 computeAccelerations() [2] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initializeVelocities() [12] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.61 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [3] +[2] 51.2 1.62 0.00 202 computeAccelerations() [2] +----------------------------------------------- + 0.00 1.61 201/201 main [1] +[3] 50.9 0.00 1.61 201 VelocityVerlet(double, int, _IO_FILE*) [3] + 1.61 0.00 201/202 computeAccelerations() [2] +----------------------------------------------- + 1.34 0.00 201/201 main [1] +[4] 42.5 1.34 0.00 201 Potential() [4] +----------------------------------------------- + +[5] 6.3 0.20 0.00 _init [5] +----------------------------------------------- + 0.00 0.00 3240/3240 initializeVelocities() [12] +[9] 0.0 0.00 0.00 3240 _dl_relocate_static_pie [9] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[12] 0.0 0.00 0.00 1 initializeVelocities() [12] + 0.00 0.00 3240/3240 _dl_relocate_static_pie [9] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [2] computeAccelerations() [9] _dl_relocate_static_pie + [3] VelocityVerlet(double, int, _IO_FILE*) [12] initializeVelocities() [5] _init + [10] MeanSquaredVelocity() [4] Potential() diff --git a/analysis/15-10__00_20_24.dot b/analysis/15-10__00_20_24.dot new file mode 100644 index 0000000..37f46ae --- /dev/null +++ b/analysis/15-10__00_20_24.dot @@ -0,0 +1,14 @@ +digraph { + graph [fontname=Arial, nodesep=0.125, ranksep=0.25]; + node [fontcolor=white, fontname=Arial, height=0, shape=box, style=filled, width=0]; + edge [fontname=Arial]; + 1 [color="#fe0400", fontcolor="#ffffff", fontsize="10.00", label="main\n99.62%\n(0.00%)"]; + 1 -> 3 [arrowsize="0.96", color="#f44902", fontcolor="#f44902", fontsize="10.00", label="92.69%\n1×", labeldistance="3.71", penwidth="3.71"]; + 1 -> 5 [arrowsize="0.35", color="#0d2b7c", fontcolor="#0d2b7c", fontsize="10.00", label="6.89%\n201×", labeldistance="0.50", penwidth="0.50"]; + 2 [color="#f44902", fontcolor="#ffffff", fontsize="10.00", label="_dl_relocate_static_pie\n92.69%\n(92.69%)\n3240×"]; + 3 [color="#f44902", fontcolor="#ffffff", fontsize="10.00", label="initializeVelocities()\n92.69%\n(0.00%)\n1×"]; + 3 -> 2 [arrowsize="0.96", color="#f44902", fontcolor="#f44902", fontsize="10.00", label="92.69%\n3240×", labeldistance="3.71", penwidth="3.71"]; + 4 [color="#0d2b7c", fontcolor="#ffffff", fontsize="10.00", label="computeAccelerations()\n6.93%\n(6.93%)\n202×"]; + 5 [color="#0d2b7c", fontcolor="#ffffff", fontsize="10.00", label="VelocityVerlet(double, int, _IO_FILE*)\n6.89%\n(0.00%)\n201×"]; + 5 -> 4 [arrowsize="0.35", color="#0d2b7c", fontcolor="#0d2b7c", fontsize="10.00", label="6.89%\n201×", labeldistance="0.50", penwidth="0.50"]; +} diff --git a/analysis/15-10__00_20_24.txt b/analysis/15-10__00_20_24.txt new file mode 100644 index 0000000..12d1cea --- /dev/null +++ b/analysis/15-10__00_20_24.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 92.78 19.53 19.53 3240 0.01 0.01 _dl_relocate_static_pie + 6.94 20.99 1.46 202 0.01 0.01 computeAccelerations() + 0.38 21.07 0.08 _init + 0.00 21.07 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 21.07 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 21.07 0.00 1 0.00 0.00 initialize() + 0.00 21.07 0.00 1 0.00 19.53 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.05% of 21.07 seconds + +index % time self children called name + +[1] 99.6 0.00 20.99 main [1] + 0.00 19.53 1/1 initializeVelocities() [3] + 0.00 1.45 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 19.53 0.00 3240/3240 initializeVelocities() [3] +[2] 92.7 19.53 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 19.53 1/1 main [1] +[3] 92.7 0.00 19.53 1 initializeVelocities() [3] + 19.53 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.45 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 6.9 1.46 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.45 201/201 main [1] +[5] 6.9 0.00 1.45 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.45 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.4 0.08 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_29_40.dot b/analysis/15-10__00_29_40.dot new file mode 100644 index 0000000..98a0105 --- /dev/null +++ b/analysis/15-10__00_29_40.dot @@ -0,0 +1,15 @@ +digraph { + graph [fontname=Arial, nodesep=0.125, ranksep=0.25]; + node [fontcolor=white, fontname=Arial, height=0, shape=box, style=filled, width=0]; + edge [fontname=Arial]; + 1 [color="#fe0700", fontcolor="#ffffff", fontsize="10.00", label="main\n99.31%\n(0.00%)"]; + 1 -> 3 [arrowsize="0.96", color="#f25302", fontcolor="#f25302", fontsize="10.00", label="91.53%\n1×", labeldistance="3.66", penwidth="3.66"]; + 1 -> 5 [arrowsize="0.35", color="#0d2f7d", fontcolor="#0d2f7d", fontsize="10.00", label="7.74%\n201×", labeldistance="0.50", penwidth="0.50"]; + 2 [color="#f25302", fontcolor="#ffffff", fontsize="10.00", label="_dl_relocate_static_pie\n91.53%\n(91.53%)\n3240×"]; + 3 [color="#f25302", fontcolor="#ffffff", fontsize="10.00", label="initializeVelocities()\n91.53%\n(0.00%)\n1×"]; + 3 -> 2 [arrowsize="0.96", color="#f25302", fontcolor="#f25302", fontsize="10.00", label="91.53%\n3240×", labeldistance="3.66", penwidth="3.66"]; + 4 [color="#0d307d", fontcolor="#ffffff", fontsize="10.00", label="computeAccelerations()\n7.78%\n(7.78%)\n202×"]; + 5 [color="#0d2f7d", fontcolor="#ffffff", fontsize="10.00", label="VelocityVerlet(double, int, _IO_FILE*)\n7.74%\n(0.00%)\n201×"]; + 5 -> 4 [arrowsize="0.35", color="#0d2f7d", fontcolor="#0d2f7d", fontsize="10.00", label="7.74%\n201×", labeldistance="0.50", penwidth="0.50"]; + 6 [color="#0d1074", fontcolor="#ffffff", fontsize="10.00", label="_init\n0.69%\n(0.69%)"]; +} diff --git a/analysis/15-10__00_29_40.txt b/analysis/15-10__00_29_40.txt new file mode 100644 index 0000000..cbacf06 --- /dev/null +++ b/analysis/15-10__00_29_40.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 91.62 16.00 16.00 3240 0.00 0.00 _dl_relocate_static_pie + 7.80 17.36 1.36 202 0.01 0.01 computeAccelerations() + 0.69 17.48 0.12 _init + 0.00 17.48 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 17.48 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 17.48 0.00 1 0.00 0.00 initialize() + 0.00 17.48 0.00 1 0.00 16.00 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.06% of 17.48 seconds + +index % time self children called name + +[1] 99.3 0.00 17.36 main [1] + 0.00 16.00 1/1 initializeVelocities() [3] + 0.00 1.35 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 16.00 0.00 3240/3240 initializeVelocities() [3] +[2] 91.5 16.00 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 16.00 1/1 main [1] +[3] 91.5 0.00 16.00 1 initializeVelocities() [3] + 16.00 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.35 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 7.8 1.36 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.35 201/201 main [1] +[5] 7.8 0.00 1.35 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.35 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.7 0.12 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_31_08.txt b/analysis/15-10__00_31_08.txt new file mode 100644 index 0000000..b3c72dd --- /dev/null +++ b/analysis/15-10__00_31_08.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 94.75 24.45 24.45 3240 0.01 0.01 _dl_relocate_static_pie + 5.24 25.80 1.35 202 0.01 0.01 computeAccelerations() + 0.12 25.83 0.03 _init + 0.00 25.83 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 25.83 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 25.83 0.00 1 0.00 0.00 initialize() + 0.00 25.83 0.00 1 0.00 24.45 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.04% of 25.83 seconds + +index % time self children called name + +[1] 99.9 0.00 25.80 main [1] + 0.00 24.45 1/1 initializeVelocities() [3] + 0.00 1.34 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 24.45 0.00 3240/3240 initializeVelocities() [3] +[2] 94.7 24.45 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 24.45 1/1 main [1] +[3] 94.7 0.00 24.45 1 initializeVelocities() [3] + 24.45 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.34 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 5.2 1.35 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.34 201/201 main [1] +[5] 5.2 0.00 1.34 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.34 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.1 0.03 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_31_31.txt b/analysis/15-10__00_31_31.txt new file mode 100644 index 0000000..2583340 --- /dev/null +++ b/analysis/15-10__00_31_31.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 92.56 20.01 20.01 3240 0.01 0.01 _dl_relocate_static_pie + 7.22 21.57 1.56 202 0.01 0.01 computeAccelerations() + 0.32 21.64 0.07 _init + 0.00 21.64 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 21.64 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 21.64 0.00 1 0.00 0.00 initialize() + 0.00 21.64 0.00 1 0.00 20.01 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.05% of 21.64 seconds + +index % time self children called name + +[1] 99.7 0.00 21.57 main [1] + 0.00 20.01 1/1 initializeVelocities() [3] + 0.00 1.55 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 20.01 0.00 3240/3240 initializeVelocities() [3] +[2] 92.5 20.01 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 20.01 1/1 main [1] +[3] 92.5 0.00 20.01 1 initializeVelocities() [3] + 20.01 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.55 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 7.2 1.56 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.55 201/201 main [1] +[5] 7.2 0.00 1.55 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.55 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.3 0.07 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_35_14.txt b/analysis/15-10__00_35_14.txt new file mode 100644 index 0000000..f9c91d4 --- /dev/null +++ b/analysis/15-10__00_35_14.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 88.74 13.28 13.28 3240 0.00 0.00 _dl_relocate_static_pie + 10.70 14.89 1.60 202 0.01 0.01 computeAccelerations() + 0.67 14.99 0.10 _init + 0.00 14.99 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 14.99 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 14.99 0.00 1 0.00 0.00 initialize() + 0.00 14.99 0.00 1 0.00 13.28 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.07% of 14.99 seconds + +index % time self children called name + +[1] 99.3 0.00 14.89 main [1] + 0.00 13.28 1/1 initializeVelocities() [3] + 0.00 1.59 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 13.28 0.00 3240/3240 initializeVelocities() [3] +[2] 88.6 13.28 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 13.28 1/1 main [1] +[3] 88.6 0.00 13.28 1 initializeVelocities() [3] + 13.28 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.59 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 10.7 1.60 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.59 201/201 main [1] +[5] 10.6 0.00 1.59 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.59 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.7 0.10 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_35_37.txt b/analysis/15-10__00_35_37.txt new file mode 100644 index 0000000..98a08d9 --- /dev/null +++ b/analysis/15-10__00_35_37.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 84.43 9.17 9.17 3240 0.00 0.00 _dl_relocate_static_pie + 14.93 10.79 1.62 202 0.01 0.01 computeAccelerations() + 0.46 10.84 0.05 _init + 0.28 10.87 0.03 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 10.87 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 10.87 0.00 1 0.00 0.00 initialize() + 0.00 10.87 0.00 1 0.00 9.17 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.09% of 10.87 seconds + +index % time self children called name + +[1] 99.5 0.00 10.82 main [1] + 0.00 9.17 1/1 initializeVelocities() [3] + 0.03 1.61 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.01 0.00 1/202 computeAccelerations() [5] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 9.17 0.00 3240/3240 initializeVelocities() [3] +[2] 84.3 9.17 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 9.17 1/1 main [1] +[3] 84.3 0.00 9.17 1 initializeVelocities() [3] + 9.17 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.03 1.61 201/201 main [1] +[4] 15.1 0.03 1.61 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 1.61 0.00 201/202 computeAccelerations() [5] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.61 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[5] 14.9 1.62 0.00 202 computeAccelerations() [5] +----------------------------------------------- + +[6] 0.5 0.05 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [5] computeAccelerations() [6] _init + [4] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_36_25.txt b/analysis/15-10__00_36_25.txt new file mode 100644 index 0000000..4005a61 --- /dev/null +++ b/analysis/15-10__00_36_25.txt @@ -0,0 +1,183 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 62.15 3.34 3.34 201 16.64 16.64 Potential() + 36.10 5.29 1.94 202 9.61 9.61 computeAccelerations() + 1.86 5.39 0.10 _init + 0.00 5.39 0.00 3240 0.00 0.00 _dl_relocate_static_pie + 0.00 5.39 0.00 201 0.00 9.61 VelocityVerlet(double, int, _IO_FILE*) + 0.00 5.39 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 5.39 0.00 1 0.00 0.00 initialize() + 0.00 5.39 0.00 1 0.00 0.00 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.19% of 5.39 seconds + +index % time self children called name + +[1] 98.1 0.00 5.29 main [1] + 3.34 0.00 201/201 Potential() [2] + 0.00 1.93 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.01 0.00 1/202 computeAccelerations() [3] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initializeVelocities() [12] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 3.34 0.00 201/201 main [1] +[2] 62.1 3.34 0.00 201 Potential() [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.93 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[3] 36.1 1.94 0.00 202 computeAccelerations() [3] +----------------------------------------------- + 0.00 1.93 201/201 main [1] +[4] 35.9 0.00 1.93 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 1.93 0.00 201/202 computeAccelerations() [3] +----------------------------------------------- + +[5] 1.9 0.10 0.00 _init [5] +----------------------------------------------- + 0.00 0.00 3240/3240 initializeVelocities() [12] +[9] 0.0 0.00 0.00 3240 _dl_relocate_static_pie [9] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[12] 0.0 0.00 0.00 1 initializeVelocities() [12] + 0.00 0.00 3240/3240 _dl_relocate_static_pie [9] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [3] computeAccelerations() [9] _dl_relocate_static_pie + [4] VelocityVerlet(double, int, _IO_FILE*) [12] initializeVelocities() [5] _init + [10] MeanSquaredVelocity() [2] Potential() diff --git a/analysis/15-10__00_39_51.txt b/analysis/15-10__00_39_51.txt new file mode 100644 index 0000000..7f80e78 --- /dev/null +++ b/analysis/15-10__00_39_51.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 93.03 19.47 19.47 3240 0.01 0.01 _dl_relocate_static_pie + 6.74 20.88 1.41 202 0.01 0.01 computeAccelerations() + 0.33 20.95 0.07 _init + 0.00 20.95 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 20.95 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 20.95 0.00 1 0.00 0.00 initialize() + 0.00 20.95 0.00 1 0.00 19.47 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.05% of 20.95 seconds + +index % time self children called name + +[1] 99.7 0.00 20.88 main [1] + 0.00 19.47 1/1 initializeVelocities() [3] + 0.00 1.40 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 19.47 0.00 3240/3240 initializeVelocities() [3] +[2] 92.9 19.47 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 19.47 1/1 main [1] +[3] 92.9 0.00 19.47 1 initializeVelocities() [3] + 19.47 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.40 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 6.7 1.41 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.40 201/201 main [1] +[5] 6.7 0.00 1.40 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.40 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.3 0.07 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_44_19.txt b/analysis/15-10__00_44_19.txt new file mode 100644 index 0000000..5e08b58 --- /dev/null +++ b/analysis/15-10__00_44_19.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 94.11 25.63 25.63 3240 0.01 0.01 _dl_relocate_static_pie + 5.51 27.13 1.50 202 0.01 0.01 computeAccelerations() + 0.48 27.26 0.13 _init + 0.00 27.26 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 27.26 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 27.26 0.00 1 0.00 0.00 initialize() + 0.00 27.26 0.00 1 0.00 25.63 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.04% of 27.26 seconds + +index % time self children called name + +[1] 99.5 0.00 27.13 main [1] + 0.00 25.63 1/1 initializeVelocities() [3] + 0.00 1.49 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 25.63 0.00 3240/3240 initializeVelocities() [3] +[2] 94.0 25.63 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 25.63 1/1 main [1] +[3] 94.0 0.00 25.63 1 initializeVelocities() [3] + 25.63 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.49 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 5.5 1.50 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.49 201/201 main [1] +[5] 5.5 0.00 1.49 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.49 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.5 0.13 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_47_57.txt b/analysis/15-10__00_47_57.txt new file mode 100644 index 0000000..e69de29 diff --git a/analysis/15-10__00_48_05.txt b/analysis/15-10__00_48_05.txt new file mode 100644 index 0000000..d72616b --- /dev/null +++ b/analysis/15-10__00_48_05.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 71.39 4.30 4.30 3240 0.00 0.00 _dl_relocate_static_pie + 27.89 5.99 1.68 202 0.01 0.01 computeAccelerations() + 0.83 6.04 0.05 _init + 0.00 6.04 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 6.04 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 6.04 0.00 1 0.00 0.00 initialize() + 0.00 6.04 0.00 1 0.00 4.30 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.17% of 6.04 seconds + +index % time self children called name + +[1] 99.2 0.00 5.99 main [1] + 0.00 4.30 1/1 initializeVelocities() [3] + 0.00 1.67 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 4.30 0.00 3240/3240 initializeVelocities() [3] +[2] 71.3 4.30 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 4.30 1/1 main [1] +[3] 71.3 0.00 4.30 1 initializeVelocities() [3] + 4.30 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.67 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 27.9 1.68 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.67 201/201 main [1] +[5] 27.7 0.00 1.67 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.67 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.8 0.05 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_49_03.txt b/analysis/15-10__00_49_03.txt new file mode 100644 index 0000000..9e372a9 --- /dev/null +++ b/analysis/15-10__00_49_03.txt @@ -0,0 +1,183 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls ms/call ms/call name + 67.54 3.36 3.36 201 16.73 16.73 Potential() + 31.16 4.92 1.55 202 7.68 7.68 computeAccelerations() + 1.41 4.99 0.07 _init + 0.00 4.99 0.00 3240 0.00 0.00 _dl_relocate_static_pie + 0.00 4.99 0.00 201 0.00 7.68 VelocityVerlet(double, int, _IO_FILE*) + 0.00 4.99 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 4.99 0.00 1 0.00 0.00 initialize() + 0.00 4.99 0.00 1 0.00 0.00 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.20% of 4.99 seconds + +index % time self children called name + +[1] 98.6 0.00 4.92 main [1] + 3.36 0.00 201/201 Potential() [2] + 0.00 1.54 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.01 0.00 1/202 computeAccelerations() [3] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initializeVelocities() [12] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 3.36 0.00 201/201 main [1] +[2] 67.5 3.36 0.00 201 Potential() [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.54 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[3] 31.1 1.55 0.00 202 computeAccelerations() [3] +----------------------------------------------- + 0.00 1.54 201/201 main [1] +[4] 31.0 0.00 1.54 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 1.54 0.00 201/202 computeAccelerations() [3] +----------------------------------------------- + +[5] 1.4 0.07 0.00 _init [5] +----------------------------------------------- + 0.00 0.00 3240/3240 initializeVelocities() [12] +[9] 0.0 0.00 0.00 3240 _dl_relocate_static_pie [9] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[12] 0.0 0.00 0.00 1 initializeVelocities() [12] + 0.00 0.00 3240/3240 _dl_relocate_static_pie [9] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [3] computeAccelerations() [9] _dl_relocate_static_pie + [4] VelocityVerlet(double, int, _IO_FILE*) [12] initializeVelocities() [5] _init + [10] MeanSquaredVelocity() [2] Potential() diff --git a/analysis/15-10__00_50_01.txt b/analysis/15-10__00_50_01.txt new file mode 100644 index 0000000..46311ad --- /dev/null +++ b/analysis/15-10__00_50_01.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 56.17 2.34 2.34 3240 0.00 0.00 _dl_relocate_static_pie + 42.25 4.10 1.76 202 0.01 0.01 computeAccelerations() + 1.20 4.15 0.05 _init + 0.48 4.17 0.02 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 4.17 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 4.17 0.00 1 0.00 0.00 initialize() + 0.00 4.17 0.00 1 0.00 2.34 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.24% of 4.17 seconds + +index % time self children called name + +[1] 98.8 0.00 4.12 main [1] + 0.00 2.34 1/1 initializeVelocities() [3] + 0.02 1.75 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.01 0.00 1/202 computeAccelerations() [5] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 2.34 0.00 3240/3240 initializeVelocities() [3] +[2] 56.1 2.34 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 2.34 1/1 main [1] +[3] 56.1 0.00 2.34 1 initializeVelocities() [3] + 2.34 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.02 1.75 201/201 main [1] +[4] 42.5 0.02 1.75 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 1.75 0.00 201/202 computeAccelerations() [5] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.75 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[5] 42.2 1.76 0.00 202 computeAccelerations() [5] +----------------------------------------------- + +[6] 1.2 0.05 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [5] computeAccelerations() [6] _init + [4] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_51_34.txt b/analysis/15-10__00_51_34.txt new file mode 100644 index 0000000..0b3e6d0 --- /dev/null +++ b/analysis/15-10__00_51_34.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 73.01 4.42 4.42 3240 0.00 0.00 _dl_relocate_static_pie + 25.44 5.97 1.54 202 0.01 0.01 computeAccelerations() + 1.32 6.05 0.08 _init + 0.33 6.07 0.02 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 6.07 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 6.07 0.00 1 0.00 0.00 initialize() + 0.00 6.07 0.00 1 0.00 4.42 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.16% of 6.07 seconds + +index % time self children called name + +[1] 98.7 0.00 5.99 main [1] + 0.00 4.42 1/1 initializeVelocities() [3] + 0.02 1.53 201/201 VelocityVerlet(double, int, _IO_FILE*) [4] + 0.01 0.00 1/202 computeAccelerations() [5] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 4.42 0.00 3240/3240 initializeVelocities() [3] +[2] 72.9 4.42 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 4.42 1/1 main [1] +[3] 72.9 0.00 4.42 1 initializeVelocities() [3] + 4.42 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.02 1.53 201/201 main [1] +[4] 25.6 0.02 1.53 201 VelocityVerlet(double, int, _IO_FILE*) [4] + 1.53 0.00 201/202 computeAccelerations() [5] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.53 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [4] +[5] 25.4 1.54 0.00 202 computeAccelerations() [5] +----------------------------------------------- + +[6] 1.3 0.08 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [5] computeAccelerations() [6] _init + [4] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_52_18.txt b/analysis/15-10__00_52_18.txt new file mode 100644 index 0000000..b3446cf --- /dev/null +++ b/analysis/15-10__00_52_18.txt @@ -0,0 +1,179 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 74.12 4.65 4.65 3240 0.00 0.00 _dl_relocate_static_pie + 24.87 6.22 1.56 202 0.01 0.01 computeAccelerations() + 0.96 6.28 0.06 _init + 0.16 6.29 0.01 main + 0.00 6.29 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 6.29 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 6.29 0.00 1 0.00 0.00 initialize() + 0.00 6.29 0.00 1 0.00 4.65 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.16% of 6.29 seconds + +index % time self children called name + +[1] 99.0 0.01 6.22 main [1] + 0.00 4.65 1/1 initializeVelocities() [3] + 0.00 1.55 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 4.65 0.00 3240/3240 initializeVelocities() [3] +[2] 74.0 4.65 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 4.65 1/1 main [1] +[3] 74.0 0.00 4.65 1 initializeVelocities() [3] + 4.65 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.55 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 24.8 1.56 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.55 201/201 main [1] +[5] 24.7 0.00 1.55 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.55 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 1.0 0.06 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() [1] main + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/analysis/15-10__00_53_56.txt b/analysis/15-10__00_53_56.txt new file mode 100644 index 0000000..4b9531c --- /dev/null +++ b/analysis/15-10__00_53_56.txt @@ -0,0 +1,178 @@ +Flat profile: + +Each sample counts as 0.01 seconds. + % cumulative self self total + time seconds seconds calls s/call s/call name + 70.91 3.91 3.91 3240 0.00 0.00 _dl_relocate_static_pie + 28.29 5.48 1.56 202 0.01 0.01 computeAccelerations() + 0.91 5.53 0.05 _init + 0.00 5.53 0.00 201 0.00 0.01 VelocityVerlet(double, int, _IO_FILE*) + 0.00 5.53 0.00 201 0.00 0.00 MeanSquaredVelocity() + 0.00 5.53 0.00 1 0.00 0.00 initialize() + 0.00 5.53 0.00 1 0.00 3.91 initializeVelocities() + + % the percentage of the total running time of the +time program used by this function. + +cumulative a running sum of the number of seconds accounted + seconds for by this function and those listed above it. + + self the number of seconds accounted for by this +seconds function alone. This is the major sort for this + listing. + +calls the number of times this function was invoked, if + this function is profiled, else blank. + + self the average number of milliseconds spent in this +ms/call function per call, if this function is profiled, + else blank. + + total the average number of milliseconds spent in this +ms/call function and its descendents per call, if this + function is profiled, else blank. + +name the name of the function. This is the minor sort + for this listing. The index shows the location of + the function in the gprof listing. If the index is + in parenthesis it shows where it would appear in + the gprof listing if it were to be printed. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + + Call graph (explanation follows) + + +granularity: each sample hit covers 2 byte(s) for 0.18% of 5.53 seconds + +index % time self children called name + +[1] 99.1 0.00 5.48 main [1] + 0.00 3.91 1/1 initializeVelocities() [3] + 0.00 1.55 201/201 VelocityVerlet(double, int, _IO_FILE*) [5] + 0.01 0.00 1/202 computeAccelerations() [4] + 0.00 0.00 201/201 MeanSquaredVelocity() [10] + 0.00 0.00 1/1 initialize() [11] +----------------------------------------------- + 3.91 0.00 3240/3240 initializeVelocities() [3] +[2] 70.8 3.91 0.00 3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.00 3.91 1/1 main [1] +[3] 70.8 0.00 3.91 1 initializeVelocities() [3] + 3.91 0.00 3240/3240 _dl_relocate_static_pie [2] +----------------------------------------------- + 0.01 0.00 1/202 main [1] + 1.55 0.00 201/202 VelocityVerlet(double, int, _IO_FILE*) [5] +[4] 28.3 1.56 0.00 202 computeAccelerations() [4] +----------------------------------------------- + 0.00 1.55 201/201 main [1] +[5] 28.1 0.00 1.55 201 VelocityVerlet(double, int, _IO_FILE*) [5] + 1.55 0.00 201/202 computeAccelerations() [4] +----------------------------------------------- + +[6] 0.9 0.05 0.00 _init [6] +----------------------------------------------- + 0.00 0.00 201/201 main [1] +[10] 0.0 0.00 0.00 201 MeanSquaredVelocity() [10] +----------------------------------------------- + 0.00 0.00 1/1 main [1] +[11] 0.0 0.00 0.00 1 initialize() [11] +----------------------------------------------- + + This table describes the call tree of the program, and was sorted by + the total amount of time spent in each function and its children. + + Each entry in this table consists of several lines. The line with the + index number at the left hand margin lists the current function. + The lines above it list the functions that called this function, + and the lines below it list the functions this one called. + This line lists: + index A unique number given to each element of the table. + Index numbers are sorted numerically. + The index number is printed next to every function name so + it is easier to look up where the function is in the table. + + % time This is the percentage of the `total' time that was spent + in this function and its children. Note that due to + different viewpoints, functions excluded by options, etc, + these numbers will NOT add up to 100%. + + self This is the total amount of time spent in this function. + + children This is the total amount of time propagated into this + function by its children. + + called This is the number of times the function was called. + If the function called itself recursively, the number + only includes non-recursive calls, and is followed by + a `+' and the number of recursive calls. + + name The name of the current function. The index number is + printed after it. If the function is a member of a + cycle, the cycle number is printed between the + function's name and the index number. + + + For the function's parents, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the function into this parent. + + children This is the amount of time that was propagated from + the function's children into this parent. + + called This is the number of times this parent called the + function `/' the total number of times the function + was called. Recursive calls to the function are not + included in the number after the `/'. + + name This is the name of the parent. The parent's index + number is printed after it. If the parent is a + member of a cycle, the cycle number is printed between + the name and the index number. + + If the parents of the function cannot be determined, the word + `' is printed in the `name' field, and all the other + fields are blank. + + For the function's children, the fields have the following meanings: + + self This is the amount of time that was propagated directly + from the child into the function. + + children This is the amount of time that was propagated from the + child's children to the function. + + called This is the number of times the function called + this child `/' the total number of times the child + was called. Recursive calls by the child are not + listed in the number after the `/'. + + name This is the name of the child. The child's index + number is printed after it. If the child is a + member of a cycle, the cycle number is printed + between the name and the index number. + + If there are any cycles (circles) in the call graph, there is an + entry for the cycle-as-a-whole. This entry shows who called the + cycle (as parents) and the members of the cycle (as children.) + The `+' recursive calls entry shows the number of function calls that + were internal to the cycle, and the calls entry for each member shows, + for that member, how many times it was called from other members of + the cycle. + +Copyright (C) 2012-2023 Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. + +Index by function name + + [11] initialize() [4] computeAccelerations() [6] _init + [5] VelocityVerlet(double, int, _IO_FILE*) [3] initializeVelocities() + [10] MeanSquaredVelocity() [2] _dl_relocate_static_pie diff --git a/input/inputdata.txt b/input/inputdata.txt new file mode 100644 index 0000000..80ef343 --- /dev/null +++ b/input/inputdata.txt @@ -0,0 +1,5 @@ +cp +Ar +100 +35000 + diff --git a/out/MD b/out/MD new file mode 100755 index 0000000000000000000000000000000000000000..348e0b11067eba65700394cac78bce47e6418c73 GIT binary patch literal 25872 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. + + Electronic Contact: foleyj10@wpunj.edu + Mail Contact: Prof. Jonathan Foley + Department of Chemistry, William Paterson University + 300 Pompton Road + Wayne NJ 07470 + + */ +#include +#include +#include +#include + +// Number of particles +int N; + +// Lennard-Jones parameters in natural units! +double sigma = 1.; +double epsilon = 1.; +double m = 1.; +double kB = 1.; + +double NA = 6.022140857e23; +double kBSI = 1.38064852e-23; // m^2*kg/(s^2*K) + +// Size of box, which will be specified in natural units +double L; + +// Initial Temperature in Natural Units +double Tinit; // 2; +// Vectors! +// +const int MAXPART = 5001; +// Position +double r[MAXPART][3]; +// Velocity +double v[MAXPART][3]; +// Acceleration +double a[MAXPART][3]; +// Force +double F[MAXPART][3]; + +// atom type +char atype[10]; +// Function prototypes +// initialize positions on simple cubic lattice, also calls function to +// initialize velocities +void initialize (); +// update positions and velocities using Velocity Verlet algorithm +// print particle coordinates to file for rendering via VMD or other animation +// software return 'instantaneous pressure' +double VelocityVerlet (double dt, int iter, FILE *fp); +// Compute Force using F = -dV/dr +// solve F = ma for use in Velocity Verlet +void computeAccelerations (); +// Numerical Recipes function for generation gaussian distribution +double gaussdist (); +// Initialize velocities according to user-supplied initial Temperature +// (Tinit) +void initializeVelocities (); +// Compute total potential energy from particle coordinates +double Potential (); +// Compute mean squared velocity from particle velocities +double MeanSquaredVelocity (); +// Compute total kinetic energy from particle mass and velocities +double Kinetic (); + +int +main () { + + // variable delcarations + int i; + double dt, Vol, Temp, Press, Pavg, Tavg, rho; + double VolFac, TempFac, PressFac, timefac; + double KE, PE, mvs, gc, Z; + char trash[10000], prefix[1000], tfn[1000], ofn[1000], afn[1000]; + FILE *infp, *tfp, *ofp, *afp; + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf (" WELCOME TO WILLY P CHEM MD!\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n ENTER A TITLE FOR YOUR CALCULATION!\n"); + scanf ("%s", prefix); + strcpy (tfn, prefix); + strcat (tfn, "_traj.xyz"); + strcpy (ofn, prefix); + strcat (ofn, "_output.txt"); + strcpy (afn, prefix); + strcat (afn, "_average.txt"); + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf (" TITLE ENTERED AS '%s'\n", prefix); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + + /* Table of values for Argon relating natural units to SI units: + * These are derived from Lennard-Jones parameters from the article + * "Liquid argon: Monte carlo and molecular dynamics calculations" + * J.A. Barker , R.A. Fisher & R.O. Watts + * Mol. Phys., Vol. 21, 657-673 (1971) + * + * mass: 6.633e-26 kg = one natural unit of mass for + *argon, by definition energy: 1.96183e-21 J = one natural unit of + *energy for argon, directly from L-J parameters length: 3.3605e-10 m = + *one natural unit of length for argon, directly from L-J parameters + * volume: 3.79499-29 m^3 = one natural unit of volume for + *argon, by length^3 time: 1.951e-12 s = one natural unit of + *time for argon, by length*sqrt(mass/energy) + ***************************************************************************************/ + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // Edit these factors to be computed in terms of basic properties in + // natural units of the gas being simulated + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ( + " WHICH NOBLE GAS WOULD YOU LIKE TO SIMULATE? (DEFAULT IS ARGON)\n"); + printf ("\n FOR HELIUM, TYPE 'He' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR NEON, TYPE 'Ne' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR ARGON, TYPE 'Ar' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR KRYPTON, TYPE 'Kr' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR XENON, TYPE 'Xe' THEN PRESS 'return' TO CONTINUE\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + scanf ("%s", atype); + + if (strcmp (atype, "He") == 0) { + + VolFac = 1.8399744000000005e-29; + PressFac = 8152287.336171632; + TempFac = 10.864459551225972; + timefac = 1.7572698825166272e-12; + + } else if (strcmp (atype, "Ne") == 0) { + + VolFac = 2.0570823999999997e-29; + PressFac = 27223022.27659913; + TempFac = 40.560648991243625; + timefac = 2.1192341945685407e-12; + + } else if (strcmp (atype, "Ar") == 0) { + + VolFac = 3.7949992920124995e-29; + PressFac = 51695201.06691862; + TempFac = 142.0950000000000; + timefac = 2.09618e-12; + // strcpy(atype,"Ar"); + + } else if (strcmp (atype, "Kr") == 0) { + + VolFac = 4.5882712000000004e-29; + PressFac = 59935428.40275003; + TempFac = 199.1817584391428; + timefac = 8.051563913585078e-13; + + } else if (strcmp (atype, "Xe") == 0) { + + VolFac = 5.4872e-29; + PressFac = 70527773.72794868; + TempFac = 280.30305642163006; + timefac = 9.018957925790732e-13; + + } else { + + VolFac = 3.7949992920124995e-29; + PressFac = 51695201.06691862; + TempFac = 142.0950000000000; + timefac = 2.09618e-12; + strcpy (atype, "Ar"); + } + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n YOU ARE SIMULATING %s GAS! \n", atype); + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n YOU WILL NOW ENTER A FEW SIMULATION PARAMETERS\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n\n ENTER THE INTIAL TEMPERATURE OF YOUR GAS IN KELVIN\n"); + scanf ("%lf", &Tinit); + // Make sure temperature is a positive number! + if (Tinit < 0.) { + printf ("\n !!!!! ABSOLUTE TEMPERATURE MUST BE A POSITIVE NUMBER! " + "PLEASE TRY AGAIN WITH A POSITIVE TEMPERATURE!!!\n"); + exit (0); + } + // Convert initial temperature from kelvin to natural units + Tinit /= TempFac; + + printf ("\n\n ENTER THE NUMBER DENSITY IN moles/m^3\n"); + printf (" FOR REFERENCE, NUMBER DENSITY OF AN IDEAL GAS AT STP IS ABOUT " + "40 moles/m^3\n"); + printf (" NUMBER DENSITY OF LIQUID ARGON AT 1 ATM AND 87 K IS ABOUT " + "35000 moles/m^3\n"); + + scanf ("%lf", &rho); + + N = 10 * 216; + Vol = N / (rho * NA); + + Vol /= VolFac; + + // Limiting N to MAXPART for practical reasons + if (N >= MAXPART) { + + printf ("\n\n\n MAXIMUM NUMBER OF PARTICLES IS %i\n\n PLEASE ADJUST " + "YOUR INPUT FILE ACCORDINGLY \n\n", + MAXPART); + exit (0); + } + // Check to see if the volume makes sense - is it too small? + // Remember VDW radius of the particles is 1 natural unit of length + // and volume = L*L*L, so if V = N*L*L*L = N, then all the particles + // will be initialized with an interparticle separation equal to 2xVDW + // radius + if (Vol < N) { + + printf ("\n\n\n YOUR DENSITY IS VERY HIGH!\n\n"); + printf (" THE NUMBER OF PARTICLES IS %i AND THE AVAILABLE VOLUME IS " + "%f NATURAL UNITS\n", + N, Vol); + printf (" SIMULATIONS WITH DENSITY GREATER THAN 1 PARTCICLE/(1 " + "Natural Unit of Volume) MAY DIVERGE\n"); + printf (" PLEASE ADJUST YOUR INPUT FILE ACCORDINGLY AND RETRY\n\n"); + exit (0); + } + // Vol = L*L*L; + // Length of the box in natural units: + L = pow (Vol, (1. / 3)); + + // Files that we can write different quantities to + tfp = fopen (tfn, "w"); // The MD trajectory, coordinates of every + // particle at each timestep + ofp = fopen ( + ofn, + "w"); // Output of other quantities (T, P, gc, etc) at every timestep + afp = fopen (afn, "w"); // Average T, P, gc, etc from the simulation + + int NumTime; + if (strcmp (atype, "He") == 0) { + + // dt in natural units of time s.t. in SI it is 5 f.s. for all other + // gasses + dt = 0.2e-14 / timefac; + // We will run the simulation for NumTime timesteps. + // The total time will be NumTime*dt in natural units + // And NumTime*dt multiplied by the appropriate conversion factor for + // time in seconds + NumTime = 50000; + } else { + dt = 0.5e-14 / timefac; + NumTime = 200; + } + + // Put all the atoms in simple crystal lattice and give them random + // velocities that corresponds to the initial temperature we have + // specified + initialize (); + + // Based on their positions, calculate the ininial intermolecular forces + // The accellerations of each particle will be defined from the forces and + // their mass, and this will allow us to update their positions via + // Newton's law + computeAccelerations (); + + // Print number of particles to the trajectory file + fprintf (tfp, "%i\n", N); + + // We want to calculate the average Temperature and Pressure for the + // simulation The variables need to be set to zero initially + Pavg = 0; + Tavg = 0; + + int tenp = floor (NumTime / 10); + fprintf ( + ofp, + " time (s) T(t) (K) P(t) (Pa) " + "Kinetic En. (n.u.) Potential En. (n.u.) Total En. (n.u.)\n"); + printf (" PERCENTAGE OF CALCULATION COMPLETE:\n ["); + for (i = 0; i < NumTime + 1; i++) { + + // This just prints updates on progress of the calculation for the + // users convenience + if (i == tenp) + printf (" 10 |"); + else if (i == 2 * tenp) + printf (" 20 |"); + else if (i == 3 * tenp) + printf (" 30 |"); + else if (i == 4 * tenp) + printf (" 40 |"); + else if (i == 5 * tenp) + printf (" 50 |"); + else if (i == 6 * tenp) + printf (" 60 |"); + else if (i == 7 * tenp) + printf (" 70 |"); + else if (i == 8 * tenp) + printf (" 80 |"); + else if (i == 9 * tenp) + printf (" 90 |"); + else if (i == 10 * tenp) + printf (" 100 ]\n"); + fflush (stdout); + + // This updates the positions and velocities using Newton's Laws + // Also computes the Pressure as the sum of momentum changes from wall + // collisions / timestep which is a Kinetic Theory of gasses concept of + // Pressure + Press = VelocityVerlet (dt, i + 1, tfp); + Press *= PressFac; + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // Now we would like to calculate somethings about the system: + // Instantaneous mean velocity squared, Temperature, Pressure + // Potential, and Kinetic Energy + // We would also like to use the IGL to try to see if we can extract + // the gas constant + mvs = MeanSquaredVelocity (); + KE = Kinetic (); + PE = Potential (); + + // Temperature from Kinetic Theory + Temp = m * mvs / (3 * kB) * TempFac; + + // Instantaneous gas constant and compressibility - not well defined + // because pressure may be zero in some instances because there will be + // zero wall collisions, pressure may be very high in some instances + // because there will be a number of collisions + gc = NA * Press * (Vol * VolFac) / (N * Temp); + Z = Press * (Vol * VolFac) / (N * kBSI * Temp); + + Tavg += Temp; + Pavg += Press; + + fprintf (ofp, " %8.4e %20.12f %20.12f %20.12f %20.12f %20.12f \n", + i * dt * timefac, Temp, Press, KE, PE, KE + PE); + } + + // Because we have calculated the instantaneous temperature and pressure, + // we can take the average over the whole simulation here + Pavg /= NumTime; + Tavg /= NumTime; + Z = Pavg * (Vol * VolFac) / (N * kBSI * Tavg); + gc = NA * Pavg * (Vol * VolFac) / (N * Tavg); + fprintf (afp, + " Total Time (s) T (K) P (Pa) PV/nT " + "(J/(mol K)) Z V (m^3) N\n"); + fprintf ( + afp, + " -------------- ----------- --------------- " + "-------------- --------------- ------------ -----------\n"); + fprintf (afp, + " %8.4e %15.5f %15.5f %10.5f %10.5f " + "%10.5e %i\n", + i * dt * timefac, Tavg, Pavg, gc, Z, Vol * VolFac, N); + + printf ("\n TO ANIMATE YOUR SIMULATION, OPEN THE FILE \n '%s' WITH VMD " + "AFTER THE SIMULATION COMPLETES\n", + tfn); + printf ("\n TO ANALYZE INSTANTANEOUS DATA ABOUT YOUR MOLECULE, OPEN THE " + "FILE \n '%s' WITH YOUR FAVORITE TEXT EDITOR OR IMPORT THE DATA " + "INTO EXCEL\n", + ofn); + printf ("\n THE FOLLOWING THERMODYNAMIC AVERAGES WILL BE COMPUTED AND " + "WRITTEN TO THE FILE \n '%s':\n", + afn); + printf ("\n AVERAGE TEMPERATURE (K): %15.5f\n", Tavg); + printf ("\n AVERAGE PRESSURE (Pa): %15.5f\n", Pavg); + printf ("\n PV/nT (J * mol^-1 K^-1): %15.5f\n", gc); + printf ("\n PERCENT ERROR of pV/nT AND GAS CONSTANT: %15.5f\n", + 100 * fabs (gc - 8.3144598) / 8.3144598); + printf ("\n THE COMPRESSIBILITY (unitless): %15.5f \n", Z); + printf ("\n TOTAL VOLUME (m^3): %10.5e \n", + Vol * VolFac); + printf ("\n NUMBER OF PARTICLES (unitless): %i \n", N); + + fclose (tfp); + fclose (ofp); + fclose (afp); + + return 0; +} + +void +initialize () { + int n, p, i, j, k; + double pos; + + // Number of atoms in each direction + n = int (ceil (pow (N, 1.0 / 3))); + + // spacing between atoms along a given direction + pos = L / n; + + // index for number of particles assigned positions + p = 0; + // initialize positions + for (i = 0; i < n; i++) { + for (j = 0; j < n; j++) { + for (k = 0; k < n; k++) { + if (p < N) { + + r[p][0] = (i + 0.5) * pos; + r[p][1] = (j + 0.5) * pos; + r[p][2] = (k + 0.5) * pos; + } + p++; + } + } + } + + // Call function to initialize velocities + initializeVelocities (); + + /*********************************************** + * Uncomment if you want to see what the initial positions and velocities + are printf(" Printing initial positions!\n"); for (i=0; i= L) { + v[i][j] *= -1.; //- elastic walls + psum += 2 * m * fabs (v[i][j]) + / dt; // contribution to pressure from "right" walls + } + } + } + + /* removed, uncomment to save atoms positions */ + /*for (i=0; i= 1.0 || rsq == 0.0); + + fac = sqrt (-2.0 * log (rsq) / rsq); + gset = v1 * fac; + available = true; + + return v2 * fac; + } else { + + available = false; + return gset; + } +} diff --git a/src/MD.cpp b/src/MD.cpp new file mode 100644 index 0000000..ca24197 --- /dev/null +++ b/src/MD.cpp @@ -0,0 +1,718 @@ +/* + MD.c - a simple molecular dynamics program for simulating real gas properties + of Lennard-Jones particles. + + Copyright (C) 2016 Jonathan J. Foley IV, Chelsea Sweet, Oyewumi Akinfenwa + + 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 . + + Electronic Contact: foleyj10@wpunj.edu + Mail Contact: Prof. Jonathan Foley + Department of Chemistry, William Paterson University + 300 Pompton Road + Wayne NJ 07470 + +*/ + +#include +#include +#include +#include +#include + +// Number of particles +int N; + +// Lennard-Jones parameters in natural units! +double sigma = 1.; +double epsilon = 1.; +double m = 1.; +double kB = 1.; + +double NA = 6.022140857e23; +double kBSI = 1.38064852e-23; // m^2*kg/(s^2*K) + +// Size of box, which will be specified in natural units +double L; + +// Initial Temperature in Natural Units +double Tinit; // 2; +// Vectors! +// +const int MAXPART = 5001; +// Position +double r[MAXPART][3]; +// Velocity +double v[MAXPART][3]; +// Acceleration +double a[MAXPART][3]; +// Force +double F[MAXPART][3]; + +// atom type +char atype[10]; +// Function prototypes +// initialize positions on simple cubic lattice, also calls function to +// initialize velocities +void initialize (); +// update positions and velocities using Velocity Verlet algorithm +// print particle coordinates to file for rendering via VMD or other animation +// software return 'instantaneous pressure' +double VelocityVerlet (double dt, int iter, FILE *fp); +// Compute Force using F = -dV/dr +// solve F = ma for use in Velocity Verlet +void computeAccelerations (); +// Numerical Recipes function for generation gaussian distribution +double gaussdist (); +// Initialize velocities according to user-supplied initial Temperature +// (Tinit) +void initializeVelocities (); +// Compute total potential energy from particle coordinates +double Potential (); +// Compute mean squared velocity from particle velocities +double MeanSquaredVelocity (); +// Compute total kinetic energy from particle mass and velocities +double Kinetic (); + +int +main () { + + // variable delcarations + int i; + double dt, Vol, Temp, Press, Pavg, Tavg, rho; + double VolFac, TempFac, PressFac, timefac; + double KE, PE, mvs, gc, Z; + char trash[10000], prefix[1000], tfn[1000], ofn[1000], afn[1000]; + FILE *infp, *tfp, *ofp, *afp; + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf (" WELCOME TO WILLY P CHEM MD!\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n ENTER A TITLE FOR YOUR CALCULATION!\n"); + scanf ("%s", prefix); + strcpy (tfn, prefix); + strcat (tfn, "_traj.xyz"); + strcpy (ofn, prefix); + strcat (ofn, "_output.txt"); + strcpy (afn, prefix); + strcat (afn, "_average.txt"); + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf (" TITLE ENTERED AS '%s'\n", prefix); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + + /* Table of values for Argon relating natural units to SI units: + * These are derived from Lennard-Jones parameters from the article + * "Liquid argon: Monte carlo and molecular dynamics calculations" + * J.A. Barker , R.A. Fisher & R.O. Watts + * Mol. Phys., Vol. 21, 657-673 (1971) + * + * mass: 6.633e-26 kg = one natural unit of mass for + *argon, by definition energy: 1.96183e-21 J = one natural unit of + *energy for argon, directly from L-J parameters length: 3.3605e-10 m = + *one natural unit of length for argon, directly from L-J parameters + * volume: 3.79499-29 m^3 = one natural unit of volume for + *argon, by length^3 time: 1.951e-12 s = one natural unit of + *time for argon, by length*sqrt(mass/energy) + ***************************************************************************************/ + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // Edit these factors to be computed in terms of basic properties in + // natural units of the gas being simulated + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ( + " WHICH NOBLE GAS WOULD YOU LIKE TO SIMULATE? (DEFAULT IS ARGON)\n"); + printf ("\n FOR HELIUM, TYPE 'He' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR NEON, TYPE 'Ne' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR ARGON, TYPE 'Ar' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR KRYPTON, TYPE 'Kr' THEN PRESS 'return' TO CONTINUE\n"); + printf (" FOR XENON, TYPE 'Xe' THEN PRESS 'return' TO CONTINUE\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + scanf ("%s", atype); + + if (strcmp (atype, "He") == 0) { + + VolFac = 1.8399744000000005e-29; + PressFac = 8152287.336171632; + TempFac = 10.864459551225972; + timefac = 1.7572698825166272e-12; + } else if (strcmp (atype, "Ne") == 0) { + + VolFac = 2.0570823999999997e-29; + PressFac = 27223022.27659913; + TempFac = 40.560648991243625; + timefac = 2.1192341945685407e-12; + } else if (strcmp (atype, "Ar") == 0) { + + VolFac = 3.7949992920124995e-29; + PressFac = 51695201.06691862; + TempFac = 142.0950000000000; + timefac = 2.09618e-12; + // strcpy(atype,"Ar"); + } else if (strcmp (atype, "Kr") == 0) { + + VolFac = 4.5882712000000004e-29; + PressFac = 59935428.40275003; + TempFac = 199.1817584391428; + timefac = 8.051563913585078e-13; + } else if (strcmp (atype, "Xe") == 0) { + + VolFac = 5.4872e-29; + PressFac = 70527773.72794868; + TempFac = 280.30305642163006; + timefac = 9.018957925790732e-13; + } else { + + VolFac = 3.7949992920124995e-29; + PressFac = 51695201.06691862; + TempFac = 142.0950000000000; + timefac = 2.09618e-12; + strcpy (atype, "Ar"); + } + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n YOU ARE SIMULATING %s GAS! \n", atype); + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + + printf ( + "\n !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n YOU WILL NOW ENTER A FEW SIMULATION PARAMETERS\n"); + printf ( + " !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); + printf ("\n\n ENTER THE INTIAL TEMPERATURE OF YOUR GAS IN KELVIN\n"); + scanf ("%lf", &Tinit); + // Make sure temperature is a positive number! + if (Tinit < 0.) { + printf ("\n !!!!! ABSOLUTE TEMPERATURE MUST BE A POSITIVE " + "NUMBER! PLEASE " + "TRY AGAIN WITH A POSITIVE TEMPERATURE!!!\n"); + exit (0); + } + // Convert initial temperature from kelvin to natural units + Tinit /= TempFac; + + printf ("\n\n ENTER THE NUMBER DENSITY IN moles/m^3\n"); + printf ( + " FOR REFERENCE, NUMBER DENSITY OF AN IDEAL GAS AT STP IS ABOUT 40 " + "moles/m^3\n"); + printf ( + " NUMBER DENSITY OF LIQUID ARGON AT 1 ATM AND 87 K IS ABOUT 35000 " + "moles/m^3\n"); + + scanf ("%lf", &rho); + + N = 10 * 216; + Vol = N / (rho * NA); + + Vol /= VolFac; + + // Limiting N to MAXPART for practical reasons + if (N >= MAXPART) { + + printf ("\n\n\n MAXIMUM NUMBER OF PARTICLES IS %i\n\n PLEASE " + "ADJUST YOUR " + "INPUT FILE ACCORDINGLY \n\n", + MAXPART); + exit (0); + } + // Check to see if the volume makes sense - is it too small? + // Remember VDW radius of the particles is 1 natural unit of length + // and volume = L*L*L, so if V = N*L*L*L = N, then all the particles + // will be initialized with an interparticle separation equal to 2xVDW + // radius + if (Vol < N) { + + printf ("\n\n\n YOUR DENSITY IS VERY HIGH!\n\n"); + printf (" THE NUMBER OF PARTICLES IS %i AND THE AVAILABLE VOLUME " + "IS %f " + "NATURAL UNITS\n", + N, Vol); + printf (" SIMULATIONS WITH DENSITY GREATER THAN 1 PARTCICLE/(1 " + "Natural " + "Unit of Volume) MAY DIVERGE\n"); + printf (" PLEASE ADJUST YOUR INPUT FILE ACCORDINGLY AND RETRY\n\n"); + exit (0); + } + // Vol = L*L*L; + // Length of the box in natural units: + L = pow (Vol, (1. / 3)); + + // Files that we can write different quantities to + tfp = fopen (tfn, "w"); // The MD trajectory, coordinates of every + // particle at each timestep + ofp = fopen ( + ofn, + "w"); // Output of other quantities (T, P, gc, etc) at every timestep + afp = fopen (afn, "w"); // Average T, P, gc, etc from the simulation + + int NumTime; + if (strcmp (atype, "He") == 0) { + + // dt in natural units of time s.t. in SI it is 5 f.s. for all + // other gasses + dt = 0.2e-14 / timefac; + // We will run the simulation for NumTime timesteps. + // The total time will be NumTime*dt in natural units + // And NumTime*dt multiplied by the appropriate conversion factor + // for time in seconds + NumTime = 50000; + } else { + dt = 0.5e-14 / timefac; + NumTime = 200; + } + + // Put all the atoms in simple crystal lattice and give them random + // velocities that corresponds to the initial temperature we have + // specified + initialize (); + + // Based on their positions, calculate the ininial intermolecular forces + // The accellerations of each particle will be defined from the forces and + // their mass, and this will allow us to update their positions via + // Newton's law + computeAccelerations (); + + // Print number of particles to the trajectory file + fprintf (tfp, "%i\n", N); + + // We want to calculate the average Temperature and Pressure for the + // simulation The variables need to be set to zero initially + Pavg = 0; + Tavg = 0; + + int tenp = floor (NumTime / 10); + fprintf ( + ofp, + " time (s) T(t) (K) P(t) (Pa) " + "Kinetic En. (n.u.) Potential En. (n.u.) Total En. (n.u.)\n"); + printf (" PERCENTAGE OF CALCULATION COMPLETE:\n ["); + for (i = 0; i < NumTime + 1; i++) { + + // This just prints updates on progress of the calculation for the + // users convenience + if (i == tenp) + printf (" 10 |"); + else if (i == 2 * tenp) + printf (" 20 |"); + else if (i == 3 * tenp) + printf (" 30 |"); + else if (i == 4 * tenp) + printf (" 40 |"); + else if (i == 5 * tenp) + printf (" 50 |"); + else if (i == 6 * tenp) + printf (" 60 |"); + else if (i == 7 * tenp) + printf (" 70 |"); + else if (i == 8 * tenp) + printf (" 80 |"); + else if (i == 9 * tenp) + printf (" 90 |"); + else if (i == 10 * tenp) + printf (" 100 ]\n"); + fflush (stdout); + + // This updates the positions and velocities using Newton's Laws + // Also computes the Pressure as the sum of momentum changes from + // wall collisions / timestep which is a Kinetic Theory of gasses + // concept of Pressure + Press = VelocityVerlet (dt, i + 1, tfp); + Press *= PressFac; + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // Now we would like to calculate somethings about the system: + // Instantaneous mean velocity squared, Temperature, Pressure + // Potential, and Kinetic Energy + // We would also like to use the IGL to try to see if we can + // extract the gas constant + mvs = MeanSquaredVelocity (); + KE = Kinetic (); + PE = Potential (); + + // Temperature from Kinetic Theory + Temp = m * mvs / (3 * kB) * TempFac; + + // Instantaneous gas constant and compressibility - not well + // defined because pressure may be zero in some instances because + // there will be zero wall collisions, pressure may be very high in + // some instances because there will be a number of collisions + gc = NA * Press * (Vol * VolFac) / (N * Temp); + Z = Press * (Vol * VolFac) / (N * kBSI * Temp); + + Tavg += Temp; + Pavg += Press; + + fprintf (ofp, " %8.4e %20.12f %20.12f %20.12f %20.12f %20.12f \n", + i * dt * timefac, Temp, Press, KE, PE, KE + PE); + } + + // Because we have calculated the instantaneous temperature and pressure, + // we can take the average over the whole simulation here + Pavg /= NumTime; + Tavg /= NumTime; + Z = Pavg * (Vol * VolFac) / (N * kBSI * Tavg); + gc = NA * Pavg * (Vol * VolFac) / (N * Tavg); + fprintf (afp, + " Total Time (s) T (K) P (Pa) PV/nT " + "(J/(mol K)) Z V (m^3) N\n"); + fprintf ( + afp, + " -------------- ----------- --------------- " + "-------------- --------------- ------------ -----------\n"); + fprintf ( + afp, + " %8.4e %15.5f %15.5f %10.5f %10.5f %10.5e " + " %i\n", + i * dt * timefac, Tavg, Pavg, gc, Z, Vol * VolFac, N); + + printf ("\n TO ANIMATE YOUR SIMULATION, OPEN THE FILE \n '%s' WITH VMD " + "AFTER THE SIMULATION COMPLETES\n", + tfn); + printf ( + "\n TO ANALYZE INSTANTANEOUS DATA ABOUT YOUR MOLECULE, OPEN THE FILE " + "\n " + " '%s' WITH YOUR FAVORITE TEXT EDITOR OR IMPORT THE DATA INTO EXCEL\n", + ofn); + printf ("\n THE FOLLOWING THERMODYNAMIC AVERAGES WILL BE COMPUTED AND " + "WRITTEN TO THE FILE \n '%s':\n", + afn); + printf ("\n AVERAGE TEMPERATURE (K): %15.5f\n", Tavg); + printf ("\n AVERAGE PRESSURE (Pa): %15.5f\n", Pavg); + printf ("\n PV/nT (J * mol^-1 K^-1): %15.5f\n", gc); + printf ("\n PERCENT ERROR of pV/nT AND GAS CONSTANT: %15.5f\n", + 100 * fabs (gc - 8.3144598) / 8.3144598); + printf ("\n THE COMPRESSIBILITY (unitless): %15.5f \n", Z); + printf ("\n TOTAL VOLUME (m^3): %10.5e \n", + Vol * VolFac); + printf ("\n NUMBER OF PARTICLES (unitless): %i \n", N); + + fclose (tfp); + fclose (ofp); + fclose (afp); + + return 0; +} + +void +initialize () { + int n, p, i, j, k; + double pos; + + // Number of atoms in each direction + n = int (ceil (pow (N, 1.0 / 3))); + + // spacing between atoms along a given direction + pos = L / n; + + // index for number of particles assigned positions + p = 0; + // initialize positions + for (i = 0; i < n; i++) { + for (j = 0; j < n; j++) { + for (k = 0; k < n; k++) { + if (p < N) { + + r[p][0] = (i + 0.5) * pos; + r[p][1] = (j + 0.5) * pos; + r[p][2] = (k + 0.5) * pos; + } + p++; + } + } + } + + // Call function to initialize velocities + initializeVelocities (); + + /*********************************************** + * Uncomment if you want to see what the initial positions and velocities + are printf(" Printing initial positions!\n"); for (i=0; i= L) { + v[i][j] *= -1.; //- elastic walls + psum + += 2 * m * fabs (v[i][j]) / dt; // contribution to pressure + // from "right" walls + } + } + } + + /* removed, uncomment to save atoms positions */ + /*for (i=0; i= 1.0 || rsq == 0.0); + + fac = sqrt (-2.0 * log (rsq) / rsq); + gset = v1 * fac; + available = true; + + return v2 * fac; + } else { + + available = false; + return gset; + } +}