dest="plot",
required=False,
default=False,
action="store_true",
help="Plot probabilities from start state per bin and iteration")
# Initialize
args = parser.parse_args()
first_iteration = 0
last_iteration = args.last_iteration
logger = Logger(args.logdir)
if last_iteration < 0:
last_iteration = logger.getLastIterationId()
# get the bin Ids of start state and target state
start_state = args.start_state
target_state = args.target_state
last_iteration_tmp = logger.loadIteration(last_iteration)
found_target_state = False
for this_bin in last_iteration_tmp.bins:
if all(this_bin.getCoordinateIds() == start_state):
start_state_id = this_bin.getId()
if all(this_bin.getCoordinateIds() == target_state):
target_state_id = this_bin.getId()
found_target_state = True
if found_target_state == False:
target_state_id = 1e99
print('Warning: Target state not found in given iterations')
current_iteration = logger.loadIteration(first_iteration)
# assign initial probabilities
N = current_iteration.getNumberOfSegments()
dest="target_bin",
metavar="INT",
required=True,
type=int,
help="Extract pathways arriving in this bin.")
# Initialize
args = parser.parse_args()
rundir = args.rundir.strip('/')
logdir = args.logdir.strip('/')
target_bin = args.target_bin
logger = Logger(args.logdir)
last_iteration_id = args.last_iteration_id
if last_iteration_id < 0:
last_iteration_id = logger.getLastIterationId()
last_iteration = logger.loadIteration(last_iteration_id)
pathways = []
sys.stdout.write('\033[1mana_SS_Pathways\033[0m\n')
sys.stdout.write(' Analyzing\n')
sys.stdout.write(' - Target bin: {} (Coordinate Ids: {})\n'.format(
target_bin, last_iteration.bins[target_bin].getCoordinateIds()))
sys.stdout.flush()
# Initialize pathways from segments in target bin
for this_segment in last_iteration.bins[target_bin].segments:
pathways.append(Pathway(this_segment))
sys.stdout.write(
' - Found {} pathways ending in target bin in iteration {}\n'.format(
len(pathways), last_iteration_id))
sys.stdout.flush()
#get the Iterations with coordinate files from logger module
sys.stdout.write(" Loading iterations\n")
if args.last_iteration == -1:
args.last_iteration = logger.getLastIterationId()
#Calculate the coordinate values and store them together with
#the trajectory probability into coordinates
coords = {'run': [], 'initial':[]} # coordinates of segments
probs = {'run': [], 'initial':[]} # probabilities of segments
n_segments = 0
n_initial_segments = 0
N_ITERATIONS = args.last_iteration - args.first_iteration
# read in initial_segment coordinates and probabilities
prev_iteration = logger.loadIteration(args.first_iteration)
for iteration_id in range(args.first_iteration + 1, args.last_iteration+1):
iteration = logger.loadIteration(iteration_id)
if len(iteration.bins) <= args.bin_id:
continue
if args.bin_id:
bins_to_scan = [iteration.bins[args.bin_id]]
else:
bins_to_scan = iteration.bins
sys.stdout.write(' Reading coordinates for segments of iteration '\
'{it_id:08d}/{first_it:05d}-{last_it:05d}'\
'\r'.format(it_id = iteration_id,
first_it = args.first_iteration,
last_it = args.last_iteration))
sys.stdout.flush()
if REWEIGHTING_RANGE > 0:
reweighter = reweighting.Reweighting( reweighting_range = REWEIGHTING_RANGE )
# Initiate iterations
if APPEND == True:
# load the last two iterations if existing for proper function of
# cleanup module
if logger.getLastIterationId() > 1:
iterations = logger.loadLastIterations(N=2)
else:
logger.loadLastIterations(N=1)
# Load the previous iterations to restore the rate matrices for the reweighter module
if REWEIGHTING_RANGE > 0 and iterations[-1].getId() <= REWEIGHTING_MAX_ITERATION:
print('Loading previous iterations to restore rate matrix for reweighting...')
for iteration_counter_tmp in range(1,iterations[-1].getId() + 1):
iteration_tmp = logger.loadIteration(iteration_counter_tmp)
reweighter.storeRateMatrix(iteration_tmp)
iteration_tmp = []
if APPEND_NEW_CONFIG:
iterations[-1].boundaries = INITIAL_BOUNDARIES
iterations[-1].sample_region = INITIAL_SAMPLE_REGION
iterations[-1].target_number_of_segments = INITIAL_TARGET_NUMBER_OF_SEGMENTS
for this_bin in iterations[-1].bins:
this_bin.target_number_of_segments = iterations[-1].target_number_of_segments
this_bin.sample_region = iterations[-1].isInSampleRegion(this_bin.getCoordinateIds())
#TODO: check if all files are present
else:
iterations.append(initiate.createInitialIteration(STARTING_STRUCTURES,
WORKDIR,
first_it_id = args.first_iteration
last_it_id = args.last_iteration
if args.plot:
import matplotlib.pyplot as plt
# failproofing for segment plotting
if first_it_id == last_it_id and \
args.plot_segments:
raise Exception("Need more than 1 iteration for --segments\n")
#get the actual Iteration from logger module
logger = Logger(args.logdir)
keep_coords_frequency = int(
logger.loadConfigParameter('keep-coords-frequency',
iteration_id=first_it_id))
first_iteration = logger.loadIteration(first_it_id)
if last_it_id == -1:
last_it_id = logger.getLastIterationId()
# load md module
if not args.input_md_conf:
args.input_md_conf = logger.loadConfigFile(first_iteration.getId())
md_module = MD_module(args.input_md_conf, debug=False)
# Load cpptraj input file as one string with linebreaks and delete the last line break
try:
cpptraj_lines_file = open(args.cpptraj_lines_file_path, 'r')
except:
print('Error: could not open ' + args.cpptraj_lines_file_path)
cpptraj_lines = ''
for line in cpptraj_lines_file:
'--skip',
dest="skip_bins",
type=int,
default=0,
help="Number of bins to be skipped upon copying.")
parser.add_argument('-f',
'--overwrite',
dest="overwrite",
default=False,
action='store_true',
help="Overwrite output files.")
args = parser.parse_args()
logger = Logger(args.logdir)
try:
iteration = logger.loadIteration(args.iteration_index)
except IOError:
print("Could not find file for iteration {}!".format(args.iteration_index))
sys.exit(-1)
if not args.overwrite:
print("Running dry! Use -f to save changes.")
# Change target number of segments if required
if args.bins_target:
for binId, targetNumberOfSegments in zip(*[iter(args.bins_target)] * 2):
print("bin: {} targetNumberOfSegments: {} --> {}".format(
binId, iteration.bins[binId].getTargetNumberOfSegments(),
targetNumberOfSegments))
iteration.bins[
binId].target_number_of_segments = targetNumberOfSegments
