Finnigan/ScanEvent.pm

filter: Statementstmt 63.1% 60 / 95 Branchbran 58.3% 14 / 24 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 58.6% 17 / 29 Podpod 100% 18 / 18 totaltotal 65.6% 109 / 166 CC 14 SCAR 12.8
CC
14
Cov
62%
purge_unused_data
12.0
converter
6.3
inverse_converter
6.3
CRAP 3.6
« Finnigan/Peaks.pm ↑ Summary Finnigan/ScanEventPreamble.pm »
1 package Finnigan::ScanEvent;
2  
3 2 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 2 ▶use warnings FATAL => qw( all );
Subroutine BEGIN: called CC=1 SCAR=0.0
5 2 our $VERSION = 0.0206;
6  
7 2 ▶use Finnigan;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 2 ▶use base 'Finnigan::Decoder';
Subroutine BEGIN: called CC=1 SCAR=0.0
9  
10 2 ▶use overload ('""' => 'stringify');
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 33 ▶sub decode {
Subroutine decode: called CC=5 SCAR=16.5
Pod documented
13 33 my ($class, $stream, $version) = @_;
14  
15 33 my @common_head = (
16 "preamble" => ['object', 'Finnigan::ScanEventPreamble'],
17 "np" => ['V', 'UInt32'],
18 );
19  
20 33 my $self = Finnigan::Decoder->read($stream, \@common_head, $version);
21 33 bless $self, $class;
22  
23 33 ▶ if ( $self->np ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->np) 23 10 33
24 23 $self->iterate_object($stream, $self->np, reaction => 'Finnigan::Reaction');
25 }
26  
27 33 my @common_middle = (
28 "unknown long[1]" => ['V', 'UInt32'],
29 "fraction collector" => ['object', 'Finnigan::FractionCollector'],
30 "nparam" => ['V', 'UInt32'],
31 );
32 33 $self->SUPER::decode($stream, \@common_middle, $version);
33  
34 33 ▶ if ( $self->nparam == 0 ) {
Branch: 3 branches
BranchTrueFalseTotal
if ($self->nparam == 0) { } 23 10 33
elsif ($self->nparam == 4) { } 0 10 10
elsif ($self->nparam == 7) { } 10 0 10
35 # do nothing
36 }
37 elsif ( $self->nparam == 4 ) {
38 0 my $fields = [
39 "unknown double" => ['d<', 'Float64'],
40 "A" => ['d<', 'Float64'],
41 "B" => ['d<', 'Float64'],
42 "C" => ['d<', 'Float64'],
43 ];
44 0 $self->SUPER::decode($stream, $fields);
45 }
46 elsif ( $self->nparam == 7 ) {
47 10 my $fields = [
48 "unknown double" => ['d<', 'Float64'],
49 "I" => ['d<', 'Float64'],
50 "A" => ['d<', 'Float64'],
51 "B" => ['d<', 'Float64'],
52 "C" => ['d<', 'Float64'],
53 "D" => ['d<', 'Float64'],
54 "E" => ['d<', 'Float64'],
55 ];
56 10 $self->SUPER::decode($stream, $fields);
57 }
58 else {
59 0 die "don't know how to interpret the set of " . $self->nparam . " conversion parameters";
60 }
61
62 33 my @common_tail = (
63 "unknown long[2]" => ['V', 'UInt32'],
64 "unknown long[3]" => ['V', 'UInt32'],
65 );
66 33 $self->SUPER::decode($stream, \@common_tail, $version);
67  
68 33 return $self;
69 }
70  
71 0 ▶sub purge_unused_data {
Subroutine purge_unused_data: not called CC=3 SCAR=24.8
Pod documented
72 0 my $self = shift;
73 0 $self->SUPER::purge_unused_data;
74 0 $self->preamble->purge_unused_data;
75 0 $self->fraction_collector->purge_unused_data;
76 0 ▶ if ($self->precursors) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->precursors) 0 0 0
77 0 foreach my $r ( @{$self->precursors} ) {
78 0 $r->purge_unused_data;
79 }
80 }
81 0 return $self;
82 }
83  
84 60 ▶sub np {
Subroutine np: called CC=1 SCAR=0.0
Pod documented
85 # the number of precrusor ions
86 60 shift->{data}->{"np"}->{value};
87 }
88  
89 19 ▶sub preamble {
Subroutine preamble: called CC=1 SCAR=0.0
Pod documented
90 19 shift->{data}->{"preamble"}->{value};
91 }
92  
93 4 ▶sub fraction_collector {
Subroutine fraction_collector: called CC=1 SCAR=0.0
Pod documented
94 4 shift->{data}->{"fraction collector"}->{value};
95 }
96  
97 3 ▶sub precursors {
Subroutine precursors: called CC=1 SCAR=0.0
Pod documented
98 3 shift->{data}->{"reaction"}->{value};
99 }
100  
101 4 ▶sub reaction {
Subroutine reaction: called CC=1 SCAR=0.0
Pod documented
102 4 shift->{data}->{"reaction"}->{value}->[0];
103 }
104  
105 53 ▶sub nparam {
Subroutine nparam: called CC=1 SCAR=0.0
Pod documented
106 53 shift->{data}->{"nparam"}->{value};
107 }
108  
109 0 ▶sub unknown_double {
Subroutine unknown_double: not called CC=1 SCAR=6.9
Pod documented
110 0 shift->{data}->{"unknown double"}->{value};
111 }
112  
113 0 ▶sub I {
Subroutine I: not called CC=1 SCAR=6.9
Pod documented
114 0 shift->{data}->{"I"}->{value};
115 }
116  
117 0 ▶sub A {
Subroutine A: not called CC=1 SCAR=6.9
Pod documented
118 0 shift->{data}->{"A"}->{value};
119 }
120  
121 0 ▶sub B {
Subroutine B: not called CC=1 SCAR=6.9
Pod documented
122 0 shift->{data}->{"B"}->{value};
123 }
124  
125 0 ▶sub C {
Subroutine C: not called CC=1 SCAR=6.9
Pod documented
126 0 shift->{data}->{"C"}->{value};
127 }
128  
129 0 ▶sub D {
Subroutine D: not called CC=1 SCAR=6.9
Pod documented
130 0 shift->{data}->{"D"}->{value};
131 }
132  
133 0 ▶sub E {
Subroutine E: not called CC=1 SCAR=6.9
Pod documented
134 0 shift->{data}->{"E"}->{value};
135 }
136  
137 1 ▶sub converter {
Subroutine converter: called CC=4 SCAR=18.4
Pod documented
138 1 my $self = shift;
139 1 ▶ if ( $self->{data}->{nparam}->{value} == 0 ) {
Branch: 3 branches
BranchTrueFalseTotal
if ($self->{'data'}{'nparam'}{'value'} == 0) { } 0 1 1
elsif ($self->{'data'}{'nparam'}{'value'} == 4) { } 0 1 1
elsif ($self->{'data'}{'nparam'}{'value'} == 7) { } 1 0 1
140 # no conversion parameters -- no conversion
141 0 ▶ return sub{$_[0]}; # the null converter allows the M/z spectra to pass unchanged
Subroutine __ANON__: not called CC=1 SCAR=6.9
142 }
143 elsif ( $self->{data}->{nparam}->{value} == 4 ) {
144 # LTQ-FT
145 0 my $A = $self->{data}->{A}->{value};
146 0 my $B = $self->{data}->{B}->{value};
147 0 my $C = $self->{data}->{C}->{value};
148 0 ▶ return sub {$A + $B/$_[0] + $C/$_[0]/$_[0]}; # $_[0] = frequency
Subroutine __ANON__: not called CC=1 SCAR=6.9
149 }
150 elsif ( $self->{data}->{nparam}->{value} == 7 ) {
151 # Orbitrap
152 1 my $A = $self->{data}->{A}->{value};
153 1 my $B = $self->{data}->{B}->{value};
154 1 my $C = $self->{data}->{C}->{value};
155 1 ▶ return sub {$A + $B/($_[0]**2) + $C/($_[0]**4)}; # $_[0] = frequency
Subroutine __ANON__: called CC=1 SCAR=0.0
156 }
157 else {
158 0 die "don't know how to convert with " . $self->nparam . " conversion parameters";
159 }
160 }
161  
162 1 ▶sub inverse_converter {
Subroutine inverse_converter: called CC=4 SCAR=18.4
Pod documented
163 1 my $self = shift;
164 1 ▶ if ( $self->{data}->{nparam}->{value} == 0 ) {
Branch: 3 branches
BranchTrueFalseTotal
if ($self->{'data'}{'nparam'}{'value'} == 0) { } 0 1 1
elsif ($self->{'data'}{'nparam'}{'value'} == 4) { } 0 1 1
elsif ($self->{'data'}{'nparam'}{'value'} == 7) { } 1 0 1
165 # no conversion parameters -- no conversion
166 0 ▶ return sub{shift}; # the null converter allows the M/z spectra to pass unchanged
Subroutine __ANON__: not called CC=1 SCAR=6.9
167 }
168 elsif ( $self->{data}->{nparam}->{value} == 4 ) {
169 # LTQ-FT
170 0 my $A = $self->{data}->{A}->{value};
171 0 my $B = $self->{data}->{B}->{value};
172 0 my $C = $self->{data}->{C}->{value};
173 0 ▶ return sub {
Subroutine __ANON__: not called CC=1 SCAR=6.9
174 0 (-$B - sqrt($B**2 - 4*$C*($A - $_[0]))) # $_[0] == Mz
175 /
176 (2*($A - $_[0]));
177 0 };
178 }
179 elsif ( $self->{data}->{nparam}->{value} == 7 ) {
180 # Orbitrap
181 1 my $A = $self->{data}->{A}->{value};
182 1 my $B = $self->{data}->{B}->{value};
183 1 my $C = $self->{data}->{C}->{value};
184 1 ▶ return sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
185 sqrt(
186 1 (-$B - sqrt($B**2 - 4*$C*($A - $_[0]))) # $_[0] == Mz
187 /
188 (2*($A - $_[0]))
189 );
190 1 };
191 }
192 else {
193 0 die "don't know how to convert with " . $self->nparam . " conversion parameters";
194 }
195 }
196  
197 2 ▶sub stringify {
Subroutine stringify: called CC=2 SCAR=6.9
Pod documented
198 2 my $self = shift;
199  
200 2 my $p = $self->preamble;
201 2 my $f = $self->fraction_collector;
202 2 ▶ if ( $self->np ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->np) { } 1 1 2
203 1 my $pr = $self->precursors;
204 1 my $r = join ", ", map {"$_"} @$pr;
205 1 return "$p $r $f";
206 }
207 else {
208 1 return "$p $f";
209 }
210 }
211  
212  
213 2 1;
214 __END__
« Finnigan/Peaks.pm ↑ Summary Finnigan/ScanEventPreamble.pm »