view annovar_yaml/annovar_yaml.pl @ 8:9d6e7d2ddbb7 draft

Uploaded new version of xml file containing dependency for perl 5.22

#/usr/bin/perl

#perl modules use
use YAML;
use YAML::Tiny;
use YAML::XS 'LoadFile';
use Data::Dumper;
#use Data::YAML::Writer;
use Getopt::Long;
use strict;

#input required
#two modes run and edit
#Basis Yaml file [default required]
#Yaml out file [required in edit mode]
#species [default required]
#build [default required]
#protocol [default required]
#protocolversion [default required]

#basic paramters
my $edit = "0";
my $run = "0";
my $application = "0";
my $parameter_yml = "YAML_arguments_annovar.yml";
my $inyml;
my $outyml;
my $invcf;
my $outvcf;
my $yml_hash_arguments;
my %yml_hash_arguments;
my $yml_hash;
my %yml_hash;
my $yml_hash_edit;
my %yml_hash_edit;
my $in;
my $in2;
my %in;
my %in2;
my $writer;

#parameter applications
my %annovarparameters_array;
my %annovarparameters_single;
my $annovarparameters_array;
my $annovarparameters_single;

#Strings used as input parameters
#my $input_general_location_database;
#my $input_general_dir_scripts;
#my $input_general_location_scripts_coding_annovar;
#my $input_general_location_scripts_table_annovar;
my $input_annovar_build;
my $input_annovar_species;
my $inprotocol;
my $inprotocolversion;
my @inprotocol;
my @inprotocolversion;

my $input_general_settings_dot2underline;
my $input_general_settings_nastring;
my $input_general_settings_otherinfo;
my $input_general_settings_polish;
my $input_general_settings_remove;
my $input_general_settings_thread;
my $input_general_settings_inputformat;

my $input_databases_available;
my $input_databases_required;

my $input_databases_colswanted;
my $input_databases_exonicsplic;
my $input_databases_hgvs;
my $input_databases_operation;
my $input_databases_splicing;
my @input_databases_colswanted;
my @input_databases_exonicsplic;
my @input_databases_hgvs;
my @input_databases_operation;
my @input_databases_splicing;

#other variables
my $script;
my $type;
my $count;
my $column_build;
my $column_species;
my @column_build;
my @column_species;
my $pattern;
my $pattern2;
my $match;
my $match_value;
my @match_value;
my @readonly;
my %editinyml;

#Fixed values for searching hashes
my $level5 = "DATABASES";

#parameters to build command
my $protocol;
my @protocol;
my $operation;
my $argument;

GetOptions (
	#Required input
	'protocol=s' => \$inprotocol,
	'protocolversion=s' => \$inprotocolversion,
	'script=s' => \$script,
	'invcf=s' => \$invcf,
	'outvcf=s' => \$outvcf,
	'application=s' => \$application,
        'inyml=s' => \$inyml,
        'outyml=s' => \$outyml,
        'build=s'       => \$input_annovar_build,
        'species=s'   => \$input_annovar_species,
	#Optional input
	'edit' => \$edit,
	'run' => \$run,
	#variables in GENERAL
	'dot2underline=s'   => \$input_general_settings_dot2underline,
	'nastring=s'   => \$input_general_settings_nastring,
	'otherinfo=s'   => \$input_general_settings_otherinfo,
	'polish=s'   => \$input_general_settings_polish,
	'remove=s'   => \$input_general_settings_remove,
	'thread=s'   => \$input_general_settings_thread,
	'inputformat=s'  => \$input_general_settings_inputformat,
	#variables in DATABASES
	'colswanted=s'   => \$input_databases_colswanted,
	'exonicsplic=s'   => \$input_databases_exonicsplic,
	'hgvs=s'   => \$input_databases_hgvs,
	'operation=s'   => \$input_databases_operation,
	'splicing=s'   => \$input_databases_splicing,
);


#inactive options
#       'drequired=s'   => \$input_databases_required,
#       'davail=s'   => \$input_databases_available,

#       'gpathdatabase=s'   => \$input_general_location_database,
#	'gpathscripts=s'   => \$input_general_dir_scripts,
#       'gpathcodannovar=s'   => \$input_general_location_scripts_coding_annovar,
#       'gpathtabannovar=s'   => \$input_general_location_scripts_table_annovar,

#Check input parameters
#Do some checks whether all required arguments are given

#some code

#arrays with all application specific parameters
#make sure keys are unique to allow for parsing of yml! 

%annovarparameters_array = (
	"COLSWANTED" => "$input_databases_colswanted",
	"EXONICSPLIC" => "$input_databases_exonicsplic",
	"HGVS" => "$input_databases_hgvs",
	"OPERATION" => "$input_databases_operation",
	"SPLICING" => "$input_databases_splicing",
);

%annovarparameters_single = (
	"DOT2UNDERLINE" => "$input_general_settings_dot2underline",
	"NASTRING" => "$input_general_settings_nastring",
	"OTHERINFO" => "$input_general_settings_otherinfo",
	"POLISH" => "$input_general_settings_polish",
	"REMOVE" => "$input_general_settings_remove",
	"THREAD" => "$input_general_settings_thread",
	"INPUTFORMAT" => "$input_general_settings_inputformat",
);

#parameter not allowed to be edited in yml
@readonly = ("hg19","human","mouse","mm10","annovar","VERSION","TABLE_ANNOVAR","refgene","cosmic");


#converting string into arrays
@inprotocol = split (",", $inprotocol);
print "version $inprotocolversion\n";
@inprotocolversion = split (",", $inprotocolversion);
@input_databases_colswanted = split (",", $input_databases_colswanted);
@input_databases_exonicsplic = split (",", $input_databases_exonicsplic);
@input_databases_hgvs = split (",", $input_databases_hgvs );
@input_databases_operation = split (",", $input_databases_operation);
@input_databases_splicing = split (",", $input_databases_splicing);

#$in = $inyml;
#openyml_read($in);
#$in = $inyml;
#load($in);

#check if combination of application,species, build and protocol exists
#$count = "0";
#%in = $yml_hash;
#foreach (@inprotocol) {
#print "protocol $inprotocol[$count]\n";  
#$pattern = "$application:ANALYSIS:$input_annovar_species:$input_annovar_build:DATABASES:$inprotocol[$count]$inprotocolversion[$count]:NAME $inprotocol[$count]$inprotocolversion[$count]";
#@pattern = ("GENERAL:species", "GENERAL:build", "GENERAL:protocol");
#foreach @pattern {
#  parse($in, $_);
#  if ($match =~ /^1$/) { print "Present!\n"; };
#  $count++;
#  }
#}

#$in = $inyml;
#openyml_read($in);
#$in = $inyml;
#load_edit($in);

#Editing section first single values, next arrays
#print "Starting editing of strings...\n";
#foreach my $key (keys %annovarparameters_single) {
#    my $innermatch = "0";
    #print "Key: $key\n";
#    foreach my $innerkey (@readonly) {
#        if ($key =~ /^$innerkey$/) {
	    #print "Value not allowed to be changed!\n";  
#            $innermatch++; };
#        }
#    if ($innermatch >= 1) {
#	print "Skipping: $key\n";
	#Do nothing
#    } else { 
#    my $value = $annovarparameters_single{$key};
#    if ($value !~ /^$/) {
#        print "key:$key value:$value\n";
#        $pattern = "^($application:.{1,}:$key)";
#	print "pattern: $pattern\n";
#        %in = $yml_hash_edit; 
#        parse($in, $pattern);
#        print "editing value...: $match_value\n";
#        @match_value = split (':', $match_value);
# 	 my $max = scalar @match_value;
# 	 $count = "0";
#        foreach (@match_value) {
#	   if ($count == $max-1) {
#               print "$_\n";
#	       $_ =~ s/^.{1,}$/$value/g;
#	       print "after: $_ \n";
#	   }
#	   $count++;
#	}
#	print "max $max\n";
#        if ( $max == 4 ) {
#            $yml_hash_edit->{$match_value[0]}{$match_value[1]}{$match_value[2]} = $match_value[3]
#        }
#    }
#    } 
#}

#print "\n";
#my $checkkey;

#allow processing of arrays as well
#print "Starting editing of array values...\n";
#foreach my $key ( keys %annovarparameters_array) {
#    $count = "0";
    #print "COUNT: $count\n";
    #print "KEY: $key\n";
#    my @key = split (',', $key);
#    foreach my $innerkey (@key) {
#        my $innermatch = "0";
#        foreach $checkkey (@readonly) {
#            if ($innerkey =~ /^$checkkey$/) {
                #Do nothing
#                $innermatch++; };
#            }
#        if ($innermatch >= 1) {
#            print "innerkey: $innerkey skipped\n";

#       } else {
#        my $value = $annovarparameters_array{$key};
#	if ($value !~ /^$/ ) {
#	    print "Value: $value\n";
#	    my @value = split (',', $value);
#	    my $innercount = "0";
#            foreach my $innervalue (@value) {
#		if ( $innervalue !~ /^$/ ) {
#	            print "\nkey: $key innerkey: $innerkey check: $checkkey value: $innervalue\n";
#	            print "innercount: $innercount\n";
#	            $pattern = "^($application:.{1,}:$input_annovar_species:$input_annovar_build:.{1,}:@inprotocol[$innercount]$inprotocolversion[$innercount]:$key)";
#                    print "pattern: $pattern\n";
#	            %in = $yml_hash_edit;
#	            parse($in, $pattern);
#		    undef %in;
#	            print "editing value...: $match_value\n";
#	                if ($match =~ /^1$/) {
#                            @match_value = split (':', $match_value);
#                            my $max = scalar @match_value;
#                            #$count = "0";
#                            foreach (@match_value) { 
#				print "count: $count\n";
#		                if ($count == $max-1) {
#		                    print "empty_check: $_ \n";
#			            $_ =~ s/^.{1,}$/$value[$innercount]/g;
#			            print "empty_check_after: $_ \n";
#		                }                                   
#		                print "Max: $max\n";
#                                $count++;
#		            }
#			    print "change: $value[$innercount]\n";
#			    print "Max: $max\n";
#                            if ( $max == 9 ) {
#                                $yml_hash_edit->{$match_value[0]}{$match_value[1]}{$match_value[2]}{$match_value[3]}{$match_value[4]}{$match_value[5]}{$match_value[6]}{$match_value[7]} = $match_value[8]; 
#                           }
#	                } else {
#
#	                     if ($match =~ /^0$/) {   
#	                         $pattern = "^($application:.{1,}:$input_annovar_species:$input_annovar_build:.{1,}:@inprotocol[$innercount]:$inprotocolversion[$innercount])";
#                                 %in = $yml_hash_edit;
#				 parse($in, $pattern);          
#				 undef %in;
#	                         print "editing value...: $match_value\n";
#	                         if ($match > 1) {
#                                     @match_value = split (':', $match_value); 
#	                             my $max = scalar @match_value;
#				     $count = "0";
#                                     print "Max: $max\n";
#                                     if ( $max == 9 ) {
#                                         $yml_hash_edit->{$match_value[0]}{$match_value[1]}{$match_value[2]}{$match_value[3]}{$match_value[4]}{$match_value[5]}{$match_value[6]}{$innerkey} = "$innervalue";
#                                     }
# 	                         }    
#	                     }
#	                }          
#		} else {
#                #Do nothing no arugment supplied  
#		}
#	    $innercount++;
#	    }
#        } else {
#	#Do nothing no argument supplied
#        }
#	}
#    }
#$count++;
#print "\n";
#}

#print "\nFinished editing...\n";

#Create second yml file with change values originating from cli
#$in = $outyml;
#openyml_write($in);
#%in = $yml_hash_edit; 
#writeyml_edit($in);
#$in = $outyml;
#load($outyml);
#print "Finished loading second yml...\n";

#Load ymlhash with arguments
#$in = $parameter_yml;
#openyml_read($in);
#$in = $parameter_yml;
#load_arguments($in);
#print "Finished loading arguments...\n";

#Build command for application

################### stuff to replace with loop

#Starting with Annovar
#$count = "0";
#foreach (@inprotocol) {
#$protocol .= "$_$inprotocolversion[$count]";
#print "protocol $inprotocol\n";
#print "protocol_version $inprotocolversion\n";
#if ($count+1 >= scalar @inprotocol) { } else { $protocol .= "','"; };
#$count++; 
#}

#Make new array with protocol plus version
#@protocol = split (",", $protocol); 
#foreach (@protocol) {
#print "print value: $_\n";
#}

#Required as input value, not pickup from yaml file!
#$operation = $input_databases_operation;
#$operation =~ s/,/','/g;

#$count= "0";
#foreach (@inprotocol) {
#if ( $_ =~ /refgene/ ) {
#print "Entering refgene...\n";
#$argument .= "$yml_hash_arguments->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{HGVS}{$yml_hash_edit->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{HGVS}} ";
#$argument .= "--splicing $yml_hash_edit->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{SPLICING} "; 
#$argument .= "$yml_hash_arguments->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{EXONSPLIC}{$yml_hash_edit->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{EXONSPLIC}}";
#if ($count+1 >= scalar @inprotocol) { } else { $argument .= "','"; };
#} elsif ( $_ =~ /cosmic/ ) {
#print "Entering cosmic...\n";
#$argument .= "--colswanted $yml_hash_edit->{$application}{ANALYSIS}{$input_annovar_species}{$input_annovar_build}{DATABASES}{$protocol[$count]}{ARG}{COLSWANTED}";
#if ($count+1 >= scalar @inprotocol) { } else { $argument .= "','"; };
#} 
#$count++;
#}

#print "$argument\n";

#Put content to print in arrays
#my @protocol_values = ("$inprotocol","$operation","$argument");
#my @values = ("$yml_hash_edit->{$application}{GENERAL}{PATHSCRIPTS}","$yml_hash_edit->{$application}{GENERAL}{$script}","$yml_hash_edit->{$application}{GENERAL}{LOCATION_DATABASE}","$input_annovar_build","$yml_hash_arguments->{$application}{GENERAL}{REMOVE}{$yml_hash_edit->{$application}{GENERAL}{REMOVE}}","$yml_hash_arguments->{$application}{GENERAL}{DOT2UNDERLINE}{$yml_hash_edit->{$application}{GENERAL}{DOT2UNDERLINE}}","$yml_hash_arguments->{$application}{GENERAL}{OTHERINFO}{$yml_hash_edit->{$application}{GENERAL}{OTHERINFO}}","$yml_hash_edit->{$application}{GENERAL}{NASTRING}","$yml_hash_arguments->{$application}{GENERAL}{INPUTFORMAT}{$yml_hash_edit->{$application}{GENERAL}{INPUTFORMAT}}","$yml_hash_edit->{$application}{GENERAL}{THREAD}","$yml_hash_arguments->{$application}{GENERAL}{POLISH}{$yml_hash_edit->{$application}{GENERAL}{POLISH}}");

#foreach (@protocol_values) { print "line array1: $_\n" };
#foreach (@values) { print "line array2: $_\n" };

#Build actual command
#my $annovar_command = "perl $values[0]$values[1] $invcf $values[2] --buildver $values[3] $values[4] --protocol \'$protocol_values[0]\' --operation \'$protocol_values[1]\' $values[5] $values[6] --nasstring \'$values[7]\' $values[8] --arg \'$protocol_values[2]\' --thread $values[9] $values[10] --outfile $outvcf";

################### end of static code

#Printing/execting command!
#print "$annovar_command\n";

#Execute command
#Do some stuff to actual run the command...

#Build command

#my @parameters_test = $yml_hash->{ANALYSIS}{DATABASES};
#foreach (@parameters_test) {
#print "value: $_\n";
#}  
#my $test_hash = $yml_hash->{ }{map};

#print "value: $yml_hash->{ANALYSIS}{DATABASES}\n";

#Fill hashes with input yaml files
openyml_read ($parameter_yml);
openyml_read ($inyml);
load ($inyml, %yml_hash, $yml_hash);
load_arguments ($parameter_yml, %yml_hash_arguments, $yml_hash_arguments);

#Building annovar command:
my $application = 'annovar';

my $ncbiRefSeq = 'ncbiRefSeq';
my $cosmic = 'cosmic';
my $dbsnp = 'avsnp';
my $clinvar = 'clinvar';
my $class = 'class';

my $ncbiRefSeq_version = '_UMCU';
my $cosmic_version = '84';
my $dbsnp_version = '150';
my $clinvar_version = '_20180603';
my $class_version = '100519';

#species input fixed
my $input_annovar_species = "human";

#Defined in input
#my $invcf = "/hpc/cog_bioinf/pathologie/users/snouwens/Annovar_Moldia/input_vcfs/prepared_vcfs/PA-AI-201812-154T_norm_2.vcf ";
#my $outvcf = "/hpc/cog_bioinf/pathologie/users/snouwens/Annovar_Moldia/input_vcfs/prepared_vcfs/PA-AI-201812-154T_norm_2_out.vcf ";

my $language = 'perl ';

my $parse1 = 'parse1';
my $parse2 = 'parse2';

my $application_path = "$application,APPLICATION,GENERAL";

my $ncbiRefSeq_path = "$ncbiRefSeq$ncbiRefSeq_version,NAME,ANALYSIS,DATABASES";
my $cosmic_path = "$cosmic$cosmic_version,NAME,ANALYSIS,DATABASES";
my $dbsnp_path = "$dbsnp$dbsnp_version,NAME,ANALYSIS,DATABASES";
my $clinvar_path = "$clinvar$clinvar_version,NAME,ANALYSIS,DATABASES";
my $class_path = "$class$class_version,NAME,ANALYSIS,DATABASES";

#blocks to build command
my @command_building_blocks = ( 
"$language",
"$parse1,PATHSCRIPTS,$application_path",
"$parse1,TABLE_ANNOVAR,$application_path",
"$invcf",
"$parse1,LOCATION_DATABASE,$application_path",
"$parse1,SPECIES,$application_path",
"$parse1,BUILD,$application_path",
"$parse1,REMOVE,$application_path",
"--protocol \'",
"$parse2,NAME,$ncbiRefSeq_path",
"\,",
"$parse2,NAME,$cosmic_path",
"\,",
"$parse2,NAME,$dbsnp_path",
"\,",
"$parse2,NAME,$clinvar_path",
"\,",
"$parse2,NAME,$class_path",
"\' ",
"--operation \'",
"$parse2,OPERATION,$ncbiRefSeq_path",
"\'",
"\,",
"\'",
"$parse2,OPERATION,$cosmic_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,OPERATION,$dbsnp_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,OPERATION,$clinvar_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,OPERATION,$class_path",
"\' ",
"$parse1,DOT2UNDERLINE,$application_path",
"$parse1,OTHERINFO,$application_path",
"$parse1,NASTRING,$application_path",
"$parse1,INPUTFORMAT,$application_path",
"--arg \'",
"$parse2,HGVS,$ncbiRefSeq_path",
"$parse2,SPLICING,$ncbiRefSeq_path",
"$parse2,EXONSPLIC,$ncbiRefSeq_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,COLSWANTED,$cosmic_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,COLSWANTED,$dbsnp_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,COLSWANTED,$clinvar_path",
#"\'\,\'",
"\'",
"\,",
"\'",
"$parse2,COLSWANTED,$class_path",
"\' ",
"$parse1,THREAD,$application_path",
"$parse1,POLISH,$application_path",
"-outfile $outvcf "); 

print "\n";

#Setup variables for processing
my $lookup;
my %input;
my $input;
my $match1;
my $in_key;
my $in_value;
my $in_lookup;
my ($pattern1, $pattern2, $pattern3, $pattern4, $pattern5);

#Empty command
my $test_command = "";

foreach (@command_building_blocks) {
  $in = $inyml;
  $in2 = $parameter_yml;
  #print "loop1:$_\n";
  if ( $_ =~ /^,$/ ) {
    print "$_ is separator and does not require matching!\n\n";
    $test_command .= "$_";
    next;
  }
  my @values = split /\,/, $_;
  foreach (@values) {
    if ( $_ =~ /^parse1/ ) {
    #print "parse1: $in, $in2, $values[1], $values[2], $values[3], $values[4], %yml_hash, %yml_hash_arguments, $yml_hash, $yml_hash_arguments\n";
    parse1 ($in, $in2, $values[1], $values[2], $values[3], $values[4], %yml_hash, %yml_hash_arguments, $yml_hash, $yml_hash_arguments);
    print "parse1_out:$lookup...\n";
    $test_command .= "$lookup";
    $lookup = '';
    $input = '';
    %input = '';
    print "\n";
    last;
    }
    elsif ( $_ =~ /^parse2/ ) {
    #print "parse2: $in, $in2, $values[1], $values[2], $values[3], $values[4], $values[5], %yml_hash, %yml_hash_arguments, $yml_hash, $yml_hash_arguments\n";
    parse2 ($in, $in2, $values[1], $values[2], $values[3], $values[4], $values[5], %yml_hash, %yml_hash_arguments, $yml_hash, $yml_hash_arguments);
    print "parse2_out:$lookup...\n";
    $test_command .= "$lookup";
    $lookup = '';
    $input = '';
    %input = '';
    print "\n";
    last;
    }
    elsif ( $_ !~ /^parse1$/ && $_ !~ /^parse2$/ ) { print "$_ does not require matching!\n\n";
    $test_command .= "$_";
    last; 
    }
  }
}

print "\n";
print "Resulting in following command: $test_command\n";
system ($test_command);
print "Job done program stopping.\n";

#testing parse2
#%in = $inyml;
#$pattern1 = "PROTOCOL";
#$pattern2 = "$inprotocol$inprotocolversion";
#$pattern2 = "$inprotocol";
#$pattern3 = "NAME";
#$pattern4 = "ANALYSIS";
#$pattern5 = "DATABASES";
#parse2 ($in, $yml_hash_arguments, $pattern1, $pattern2, $pattern3, $pattern4, $pattern5);

#application is checked as well
#testing parse3
#%in = $inyml;
#$pattern1 = "OTHERINFO";
#$pattern2 = $application; #is value is which used for check
#patteern3 = "APPLICATION";
#$pattern4 = "GENERAL";
#parse1 ($in, $yml_hash_arguments, $pattern1, $pattern2, $pattern3, $pattern4);

exit;

#####################
#!!!END OF SCRIPT!!!#
####################

#############
#SUBROUTINES#
#############

sub check_lookup {
if ($in_lookup =~ /^$/) {
  #No argument found error, mismatch between arguments and inyml!
  print " mismatch between yml input and arguments yml!\n";
  print "Problem with following values: $in_key: $in_value!\n"; }  
elsif ($in_lookup !~ /^$/) {
  #argument found in arguments file!             
  print " found argument!\n";
  print "Following values used: $in_key:$in_value:$in_lookup!\n";
  $match1++; }
}

#############
#Subroutine to process parsing for 2-layered arrays in yamls
#############
sub parse2 { 

#presetting variables
$input = '';
%input = '';
$lookup = '';
my $find_parameter;
my $find_parameter_result;
my $count_key;
my $count_value;
my $count_inner_key;
my $count_inner_value;
my %test_value_ANALYSIS;
my %test_value_GENERAL;
my $pattern1 = $_[2];
my $pattern2 = $_[3];
my $pattern3 = $_[4];
my $pattern4 = $_[5];
my $pattern5 = $_[6];

print "Searching for matching parameter for: $pattern1...";

for my $test_value_ANALYSIS (@{$yml_hash->{$pattern4}{$pattern5}}) {
  $count_key = 0;
  foreach my $key (keys $test_value_ANALYSIS) {
    $count_key++;
    $count_value = 1;
    foreach my $value (values $test_value_ANALYSIS) {
      if ($count_value =~ /^$count_key$/) { 
        for my $test_value_ANALYSIS_arguments (@{$yml_hash_arguments->{$pattern4}{$pattern5}}) {
          $count_inner_key = 0;
          foreach my $inner_key (keys $test_value_ANALYSIS_arguments ) {
            if ( $key =~ /^$inner_key$/ ) { 
              $count_inner_key++;
              $count_inner_value = 1;
              foreach my $inner_value (values $test_value_ANALYSIS_arguments) {
                $match1 = 0;
                $lookup = "";
                if ( $test_value_ANALYSIS_arguments->{$pattern3} =~ /^$pattern2$/ && $test_value_ANALYSIS->{$pattern3} =~ /^$pattern2$/ ) {
                  if ( $count_inner_value =~ /^$count_inner_key$/ && $key =~ /^$pattern1$/) {
                    if ( $test_value_ANALYSIS_arguments->{$key} =~ /^HASH/ ) {
                      #print "\nIs hash! $key:$value:$inner_key:$inner_value:$pattern1\n";
                      $lookup = $test_value_ANALYSIS_arguments->{$key}{$value};
                      check_lookup ($in_key = $key,$in_value = $value, $in_lookup = $lookup, $match1);
                      $in_key = '';
                      $in_value = '';
                      $in_lookup = '';
                      return;
                    }
                    elsif ( $test_value_ANALYSIS_arguments->{$key} !~ /^HASH/ ) {
                      $lookup = $test_value_ANALYSIS_arguments->{$key};
                      check_lookup ($in_key = $key,$in_value = $value, $in_lookup = $lookup, $match1);
                      $in_key = '';
                      $in_value = '';
                      $in_lookup = '';
                      return; 
                    }
                  } 
                $count_inner_value++;
                }
              }
            }
          }    
        } 
      }
      $count_value++;
    }
  }
}

print " parameter not found!\n";
print "Problem with following value: $pattern1!\n";
print "Please check your yaml files for errors!\n";
print "Aborting...\n";

} 

#############
#Subroutine to process parsing of 1-layered array in yamls
#############
sub parse1 {

#presetting variables
%input = '';
$lookup = '';
my $find_parameter;
my $find_parameter_result;
my $count_key;
my $count_value;
my $count_inner_key;
my $count_inner_value;
my %test_value_ANALYSIS;
my %test_value_GENERAL;
my $pattern1 = $_[2];
my $pattern2 = $_[3];
my $pattern3 = $_[4];
my $pattern4 = $_[5];

print "Searching for matching parameter for: $pattern1...";

foreach my $find_parameter (@{$yml_hash->{$pattern4}}) {
  #print "hash: $find_parameter->{$pattern1}\n";
}

for my $test_value_ANALYSIS (@{$yml_hash->{$pattern4}}) {
  $count_key = 0;
  foreach my $key (keys $test_value_ANALYSIS) {
    $count_key++;
    $count_value = 0;
    foreach my $value (values $test_value_ANALYSIS) {
      $count_value++;
      if ($count_value =~ /^$count_key$/) {
        for my $test_value_ANALYSIS_arguments (@{$yml_hash_arguments->{$pattern4}}) {
          $count_inner_key = 0;
          foreach my $inner_key (keys $test_value_ANALYSIS_arguments ) {
            $count_inner_key++;
            $count_inner_value = 0;
            if ( $key =~ /^$inner_key$/ ) {
              foreach my $inner_value (values $test_value_ANALYSIS_arguments) {
                $count_inner_value++;
                #print "Innervalue: $inner_value $key:$value:$inner_key:$inner_value:$count_key:$count_value:$count_inner_key:$count_inner_value\n";
                $match1 = 0;
                $lookup = "";
                if ( $test_value_ANALYSIS_arguments->{$pattern3} =~ /^$pattern2$/ && $test_value_ANALYSIS->{$pattern3} =~ /^$pattern2$/ ) {
                  if ( $count_inner_value =~ /^$count_inner_key$/ && $key =~ /^$pattern1$/ ) {
                    if ( $test_value_ANALYSIS_arguments->{$key} =~ /^HASH/ ) {
                      #print "\nIs hash! $key:$value:$inner_key:$lookup:$match1\n";
                      $lookup = $test_value_ANALYSIS_arguments->{$key}{$value};
                      check_lookup ($in_key = $key,$in_value = $value, $in_lookup = $lookup, $match1);
                      $in_key = '';
                      $in_value = '';
                      $in_lookup = '';
                      return;
                    }
                    elsif ( $test_value_ANALYSIS_arguments->{$key} !~ /^HASH/ ) {
                      $lookup = $test_value_ANALYSIS_arguments->{$key};
                      #print "Is not a Hash! $lookup\n";
                      check_lookup ($in_key = $key,$in_value = $value, $in_lookup = $lookup, $match1);
                      $in_key = '';
                      $in_value = '';
                      $in_lookup = ''; 
                      return;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

print " parameter not found!\n";
print "Problem with following value: $pattern1!\n";
print "Please check your yaml files for errors!\n";
print "Aborting...\n";

} 

#############
#subroutine parsing yaml hash
#############
sub openyml_write {
my $outyml = $in; 
#Create second yml file with change values originating from cli
open(OUT, '>', "$outyml") or die "Could not open file '$outyml' $!";
print "Done creating output file...\n";
}

#############
#
#############
sub openyml_read { 
$in = $_[0];
chomp $in;
my $inyml = $in;
open(FILE, '<', "$inyml") or die "Could not open file '$inyml' $!";
close FILE;
print "Done reading\n";
}

#############
##
##############
sub load_arguments {
$in = $_[0];
$yml_hash_arguments = LoadFile($in);
return($yml_hash_arguments, %yml_hash_arguments);
}

#############
#pen(FILE, '<', "$inyml") or die "Could not open file '$inyml' $!";
##
##############
sub load {
$in = $_[0];
$yml_hash = LoadFile($in);
return($yml_hash, %yml_hash);
}

#############
##
##############
sub load_edit {
$in = $_[0];
$yml_hash_edit = LoadFile($in);
}

#############
##
##############
sub writeyml {
my $yml_hash = $in;
$writer = sub {
    my $line = shift;
    print FILE "$line\n";
};
my $file = Data::YAML::Writer->new;
$file->write( $yml_hash, $writer );
}

#############
##
##############
sub writeyml_edit {
my $yml_hash = $in;
$writer = sub {
    my $line = shift;
    print OUT "$line\n";
};
my $file = Data::YAML::Writer->new;
$file->write( $yml_hash_edit, $writer );
close OUT;
}

#############
##
##############
sub parse {
my $ymlhash = $in;

print "searching for: $pattern\n";

$match = "0";
$match_value = '';

for my $key1 (keys %{$yml_hash}) {
#print "Key1: $key1\n";
$type = '';
$type = ref(${$yml_hash}{$key1});
    if (exists $yml_hash->{$key1} || $type =~ /HASH/) {
        for my $key2 (keys %{$yml_hash->{$key1}}) {
        #print "Key2: $key2\n";
        $type = '';
        $type = ref(${$yml_hash}{$key1}{$key2});
            if (exists $yml_hash->{$key2} || $type =~ /HASH/) {
                for my $key3 (keys %{$yml_hash->{$key1}{$key2}}) {
                #print "Key3: $key3\n";
                $type = '';
                $type = ref(${$yml_hash}{$key1}{$key2}{$key3});
                    if (exists $yml_hash->{$key3} || $type =~ /HASH/) {
                        for my $key4 (keys %{$yml_hash->{$key1}{$key2}{$key3}}) {
                        #print "Key4: $key4\n";
                        $type = '';
                        $type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4});
                            if (exists $yml_hash->{$key4} || $type =~ /HASH/) {
                                for my $key5 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}}) {
                                #print "Key5: $key5\n";
                                $type = '';
                                $type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4}{$key5});
                                    if (exists $yml_hash->{$key5} || $type =~ /HASH/) {
                                        for my $key6 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}}) {
                                        #print "Key6: $key6\n";
                                        $type = '';
                                        $type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4}{$key5}{$key6});
                                            if (exists $yml_hash->{$key6} || $type =~ /HASH/) {
                                                for my $key7 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}}) {
                                                #print "Key7: $key7\n";
                                                $type = '';
                                                $type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7});
                                                    if (exists $yml_hash->{$key7} || $type =~ /HASH/) {
                                                        for my $key8 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}}) {
                                                        #print "Key8: $key8\n";
							$type = '';
							$type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8});
							    if (exists $yml_hash->{$key8} || $type =~ /HASH/) {
							        for my $key9 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}}) {
								#print "Key9: $key9\n";
								$type = '';
								$type = ref(${$yml_hash}{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9});
                                                                    if (exists $yml_hash->{$key9} || $type =~ /HASH/) {
									for my $key10 (keys %{$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}}) {
									my $value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}{$key10}";
									if ( $value =~ /$pattern/ ) {
									    $match++;
									    $match_value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}{$key10}";
									    #print "value $key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}{$key10}\n";
									}
									#print "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}{$key10}";
								    }		
								} else {	
								my $value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}";
							        if ( $value =~ /$pattern/ ) {
								    $match++;
								    $match_value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}";
								    #print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}\n";
								} 
								#print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$key9 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}{$key9}\n";
								}
							    }
							} else {
							my $value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}";
							if ( $value =~ /$pattern/ ) {
                                                            $match++;
							    $match_value =  "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}";
                                                            #print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}\n";
							}
							#print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7:$key8 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}{$key8}\n";
                                                        }
						    }
                                                } else {
						my $value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}";
						if ( $value =~ /$pattern/ ) {
						    $match++;
						    $match_value = "$key1:$key2:$key3:$key4:$key5:$key6:$key7:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}";
                                                    #print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}\n";
						}
						#print "value: $key1:$key2:$key3:$key4:$key5:$key6:$key7 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}{$key7}\n";
                                                }
                                             }
                                         } else {
					 my $value = "$key1:$key2:$key3:$key4:$key5:$key6 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}";
					 if ( $value =~ /$pattern/ ) {
					     $match++;
					     $match_value = "$key1:$key2:$key3:$key4:$key5:$key6:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}";
                                             #print "value: $key1:$key2:$key3:$key4:$key5:$key6 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}\n";
					 }
					 #print "value: $key1:$key2:$key3:$key4:$key5:$key6 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}{$key6}\n";
                                         }
                                      }
                                  } else {
				  my $value = "$key1:$key2:$key3:$key4:$key5 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}";
				  if ( $value =~ /$pattern/ ) {
				      $match++;
				      $match_value = "$key1:$key2:$key3:$key4:$key5:$yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}";
                                      #print "value: $key1:$key2:$key3:$key4:$key5 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}\n";
				  }
				  #print "value: $key1:$key2:$key3:$key4:$key5 $yml_hash->{$key1}{$key2}{$key3}{$key4}{$key5}\n";
                                  }
                               }
                           } else {
			   my $value = "$key1:$key2:$key3:$key4 $yml_hash->{$key1}{$key2}{$key3}{$key4}";
			   if ( $value =~ /$pattern/ ) {
			       $match++;
			       $match_value = "$key1:$key2:$key3:$key4:$yml_hash->{$key1}{$key2}{$key3}{$key4}";
                               #print "value: $key1:$key2:$key3:$key4 $yml_hash->{$key1}{$key2}{$key3}{$key4}\n";
			   }
			   #print "value: $key1:$key2:$key3:$key4 $yml_hash->{$key1}{$key2}{$key3}{$key4}\n";
                           }
                        }
                    } else {
		    my $value = "$key1:$key2:$key3 $yml_hash->{$key1}{$key2}{$key3}";
		    if ( $value =~ /$pattern/ ) {
			$match++;
			$match_value = "$key1:$key2:$key3:$yml_hash->{$key1}{$key2}{$key3}";
                        #print "value: $key1:$key2:$key3 $yml_hash->{$key1}{$key2}{$key3}\n";
		    }
		    #print "value: $key1:$key2:$key3 $yml_hash->{$key1}{$key2}{$key3}\n";
                    }
                }
            } else {
	    my $value = "$key1:$key2 $yml_hash->{$key1}{$key2}";
	    if ( $value =~ /$pattern/ ) {
		$match++;
		$match_value = "$key1:$key2:$yml_hash->{$key1}{$key2}";
                #print "value: $key1:$key2 $yml_hash->{$key1}{$key2}\n";
	    }
	    #print "value: $key1:$key2 $yml_hash->{$key1}{$key2}\n";
            }
        }
    } else {
    my $value = "$key1 $yml_hash->{$key1}";
    if ( $value =~ /$pattern/ ) {
	$match++;
	$match_value = "$key1:$yml_hash->{$key1}";
        #print "value: $key1 $yml_hash->{$key1}\n";
    }
    #print "value: $key1 $yml_hash->{$key1}\n";
    }
}

print "Match: $match\n";

return $match;
return $match_value;
}