/ 
HackaMol-X-Calculator-0.00_2
River stage zero No dependents
/ HackaMol::X::Calculator

NAME

HackaMol::X::Calculator - Abstract calculator class for HackaMol

VERSION

version 0.00_2

SYNOPSIS

  use Modern::Perl;
  use HackaMol;
  use HackaMol::X::Calculator;

  my $hack = HackaMol->new( 
                            name => "hackitup" , 
                            data => "local_pdbs",
                          );
   
  my $i = 0;

  foreach my $pdb ($hack->data->children(qr/\.pdb$/)){

     my $mol = $hack->read_file_mol($pdb);

     my $Calc = HackaMol::X::Calculator->new (
                   molecule => $mol,
                   scratch  => 'realtmp/tmp',
                   in_fn    => 'calc.inp'
                   out_fn   => "calc-$i.out"
                   map_in   => \&input_map,
                   map_out  => \&output_map,
                   exe      => '~/bin/xyzenergy < ', 
     );     

     $Calc->map_input;
     $Calc->capture_sys_command;
     my $energy = $Calc->map_output(627.51);

     printf ("Energy from xyz file: %10.6f\n", $energy);

     $i++;

  }

  #  our functions to map molec info to input and from output
  sub input_map {
    my $calc = shift;
    $calc->mol->print_xyz($calc->in_fn);
  }

  sub output_map {
    my $calc   = shift;
    my $conv   = shift;
    my @eners  = map { /ENERGY= (-\d+.\d+)/; $1*$conv } $calc->out_fn->lines; 
    return pop @eners;
  }

DESCRIPTION

The HackaMol::X::Calculator extension generalizes molecular calculations using external programs. The Calculator class consumes roles provided by the HackaMol core that manages the running of executables... perhaps on files; perhaps in directories. This extension is intended to provide a simple example of interfaces with external programs. It is probably too flexible. New extensions can evolve from this starting point, in scripts, to more rigid encapsulated classes. In the synopsis, The input is written (->map_input), the command is run (->capture_sys_command) and the output is processed (->map_output). Thus, the calculator can be used to 1. generate inputs, 2. run programs, 3. process outputs.

METHODS

map_input

changes to scratch directory, if set, and passes all arguments (including self) to map_in CodeRef. Thus, any input writing must

$calc->map_input(@args);

will invoke,

&{$calc->map_in}(@_);  #where @_ = ($self,@args)

and return anything returned by the map_in function.

map_output

completely analogous to map_input. Thus, the output must be opened and processed in the map_out function.

build_command

builds the command from the attributes: exe, inputfn, exe_endops, if they exist, and returns the command.

capture_sys_command

uses Capture::Tiny capture method to run a command using a system call. STDOUT, STDERR, are captured and returned.

my ($stdout, $stderr,@other) = capture { system($command) }

the $command is taken from $calc->command unless the $command is passed,

$calc->capture_sys_command($some_command);

capture_sys_command returns ($stdout, $stderr,@other) or 0 if there is no command set.

ATTRIBUTES

scratch

Coerced to be 'Path::Tiny' via AbsPath. If scratch is set, all work is carried out in that directory. See HackaMol::PathRole for more information about the scracth attribute.

mol

isa HackaMol::Molecule that is ro and required

map_in

isa CodeRef that is ro

intended for mapping input files from molecular information, but it is completely flexible. Used in map_input method. Can also be directly ivoked,

&{$calc->map_in}(@args);

as any other subroutine would be.

map_out

intended for mapping molecular information from output files, but it is completely flexible and analogous to map_in.

EXTENDS

CONSUMES

AUTHOR

Demian Riccardi <demianriccardi@gmail.com>

COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Demian Riccardi.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.