CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
AlignmentIORoot.cc
Go to the documentation of this file.
1 #include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParametersIORoot.h"
2 #include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentCorrelationsIORoot.h"
3 #include "Alignment/CommonAlignmentAlgorithm/interface/AlignableDataIORoot.h"
4 
5 // this class's header
6 #include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentIORoot.h"
7 
8 // ----------------------------------------------------------------------------
9 // write alignment parameters
10 
11 void
12 AlignmentIORoot::writeAlignmentParameters(const align::Alignables& alivec,
13  const char* filename, int iter,
14  bool validCheck, int& ierr)
15 {
16  AlignmentParametersIORoot theIO;
17  ierr=0;
18  int iret;
19  iret = theIO.open(filename,iter,true);
20  if (iret!=0) { ierr=-1; return;}
21  iret = theIO.write(alivec,validCheck);
22  if (iret!=0) { ierr=-2; return;}
23  iret = theIO.close();
24  if (iret!=0) { ierr=-3; return;}
25 }
26 
27 // ----------------------------------------------------------------------------
28 // read alignment parameters
29 align::Parameters
30 AlignmentIORoot::readAlignmentParameters(const align::Alignables& alivec,
31  const char* filename, int iter, int& ierr)
32 {
33  align::Parameters result;
34 
35  AlignmentParametersIORoot theIO;
36  ierr=0;
37  int iret;
38  iret = theIO.open(filename,iter,false);
39  if (iret!=0) { ierr=-1; return result;}
40  result = theIO.read(alivec,iret);
41  if (iret!=0) { ierr=-2; return result;}
42  iret = theIO.close();
43  if (iret!=0) { ierr=-3; return result;}
44 
45  return result;
46 }
47 
48 // ----------------------------------------------------------------------------
49 // write alignment parameters
50 void
51 AlignmentIORoot::writeOrigRigidBodyAlignmentParameters
52 (const align::Alignables& alivec, const char* filename, int iter, bool validCheck, int& ierr)
53 {
54  AlignmentParametersIORoot theIO;
55  ierr = 0;
56  int iret = theIO.open(filename, iter, true);
57  if (iret != 0) { ierr = -1; return;}
58  iret = theIO.writeOrigRigidBody(alivec, validCheck);
59  if (iret != 0) { ierr = -2; return;}
60  iret = theIO.close();
61  if (iret != 0) { ierr = -3; return;}
62 }
63 
64 
65 // ----------------------------------------------------------------------------
66 // write correlations
67 
68 void
69 AlignmentIORoot::writeCorrelations (const align::Correlations& cormap,
70  const char* filename, int iter, bool validCheck, int& ierr)
71 {
72  AlignmentCorrelationsIORoot theIO;
73  ierr=0;
74  int iret;
75  iret = theIO.open(filename,iter,true);
76  if (iret!=0) { ierr=-1; return;}
77  iret = theIO.write(cormap,validCheck);
78  if (iret!=0) { ierr=-2; return;}
79  iret = theIO.close();
80  if (iret!=0) { ierr=-3; return;}
81 }
82 
83 // ----------------------------------------------------------------------------
84 // read correlations
85 
86 align::Correlations
87 AlignmentIORoot::readCorrelations (const align::Alignables& alivec, const char* filename,
88  int iter, int& ierr)
89 {
90  align::Correlations result;
91 
92  AlignmentCorrelationsIORoot theIO;
93  ierr=0;
94  int iret;
95  iret = theIO.open(filename,iter,false);
96  if (iret!=0) { ierr=-1; return result;}
97  result = theIO.read(alivec,iret);
98  if (iret!=0) { ierr=-2; return result;}
99  iret = theIO.close();
100  if (iret!=0) { ierr=-3; return result;}
101 
102  return result;
103 }
104 
105 
106 // ----------------------------------------------------------------------------
107 // write absolute position of alignable
108 
109 void AlignmentIORoot::writeAlignableAbsolutePositions ( const align::Alignables& alivec,
110  const char* filename, int iter,
111  bool validCheck, int& ierr)
112 {
113  AlignableDataIORoot theIO(AlignableDataIORoot::Abs);
114  ierr=0;
115  int iret;
116  iret = theIO.open(filename,iter,true);
117  if (iret!=0) { ierr=-1; return;}
118  iret = theIO.writeAbsPos(alivec,validCheck);
119  if (iret!=0) { ierr=-2; return;}
120  iret = theIO.close();
121  if (iret!=0) { ierr=-3; return;}
122 }
123 
124 // ----------------------------------------------------------------------------
125 // read absolute position of alignable
126 
127 AlignablePositions
128 AlignmentIORoot::readAlignableAbsolutePositions (const align::Alignables& alivec,
129  const char* filename, int iter, int& ierr)
130 {
131  AlignablePositions result;
132 
133  AlignableDataIORoot theIO(AlignableDataIORoot::Abs);
134  ierr=0;
135  int iret;
136  iret = theIO.open(filename,iter,false);
137  if (iret!=0) { ierr=-1; return result;}
138  result = theIO.readAbsPos(alivec,iret);
139  if (iret!=0) { ierr=-2; return result;}
140  iret = theIO.close();
141  if (iret!=0) { ierr=-3; return result;}
142 
143  return result;
144 }
145 
146 // ----------------------------------------------------------------------------
147 // write original position of alignable
148 
149 void AlignmentIORoot::writeAlignableOriginalPositions ( const align::Alignables& alivec,
150  const char* filename, int iter,
151  bool validCheck, int& ierr)
152 {
153  AlignableDataIORoot theIO(AlignableDataIORoot::Org);
154  ierr=0;
155  int iret;
156  iret = theIO.open(filename,iter,true);
157  if (iret!=0) { ierr=-1; return;}
158  iret = theIO.writeOrgPos(alivec,validCheck);
159  if (iret!=0) { ierr=-2; return;}
160  iret = theIO.close();
161  if (iret!=0) { ierr=-3; return;}
162 }
163 
164 // ----------------------------------------------------------------------------
165 // read original position of alignable
166 
167 AlignablePositions
168 AlignmentIORoot::readAlignableOriginalPositions (const align::Alignables& alivec,
169  const char* filename, int iter, int& ierr)
170 {
171  AlignablePositions result;
172 
173  AlignableDataIORoot theIO(AlignableDataIORoot::Org);
174  ierr=0;
175  int iret;
176  iret = theIO.open(filename,iter,false);
177  if (iret!=0) { ierr=-1; return result;}
178  result = theIO.readOrgPos(alivec,iret);
179  if (iret!=0) { ierr=-2; return result;}
180  iret = theIO.close();
181  if (iret!=0) { ierr=-3; return result;}
182 
183  return result;
184 }
185 
186 // ----------------------------------------------------------------------------
187 // write relative position of alignable
188 
189 void AlignmentIORoot::writeAlignableRelativePositions( const align::Alignables& alivec,
190  const char* filename,
191  int iter, bool validCheck, int& ierr)
192 {
193  AlignableDataIORoot theIO(AlignableDataIORoot::Rel);
194  ierr=0;
195  int iret;
196  iret = theIO.open(filename,iter,true);
197  if (iret!=0) { ierr=-1; return;}
198  iret = theIO.writeRelPos(alivec,validCheck);
199  if (iret!=0) { ierr=-2; return;}
200  iret = theIO.close();
201  if (iret!=0) { ierr=-3; return;}
202 }
203 
204 // ----------------------------------------------------------------------------
205 // read relative position of alignable
206 
207 AlignableShifts
208 AlignmentIORoot::readAlignableRelativePositions (const align::Alignables& alivec,
209  const char* filename, int iter, int& ierr)
210 {
211  AlignableShifts result;
212 
213  AlignableDataIORoot theIO(AlignableDataIORoot::Rel);
214  ierr=0;
215  int iret;
216  iret = theIO.open(filename,iter,false);
217  if (iret!=0) { ierr=-1; return result;}
218  result = theIO.readRelPos(alivec,iret);
219  if (iret!=0) { ierr=-2; return result;}
220  iret = theIO.close();
221  if (iret!=0) { ierr=-3; return result;}
222 
223  return result;
224 }
225 
226 
227 
228 
229 
230 
AlignableDataIO::readAbsPos
AlignableAbsData readAbsPos(Alignable *ali, int &ierr)
Read absolute positions of one Alignable.
Definition: AlignableDataIO.cc:10
AlignmentIORoot::readAlignableRelativePositions
AlignableShifts readAlignableRelativePositions(const align::Alignables &alivec, const char *filename, int iter, int &ierr)
read Alignable relative positions (shift,rotation)
Definition: AlignmentIORoot.cc:208
AlignableDataIO::readOrgPos
AlignableAbsData readOrgPos(Alignable *ali, int &ierr)
Read original positions of one Alignable.
Definition: AlignableDataIO.cc:17
AlignableDataIO::writeAbsPos
int writeAbsPos(Alignable *ali, bool validCheck)
Write absolute positions of one Alignable.
Definition: AlignableDataIO.cc:31
AlignmentParametersIO::write
int write(const align::Alignables &alivec, bool validCheck)
write AlignmentParameters of many Alignables
Definition: AlignmentParametersIO.cc:29
AlignmentCorrelationsIORoot::read
align::Correlations read(const align::Alignables &alivec, int &ierr)
read correlations
Definition: AlignmentCorrelationsIORoot.cc:79
AlignmentIORoot::writeAlignableOriginalPositions
void writeAlignableOriginalPositions(const align::Alignables &alivec, const char *filename, int iter, bool validCheck, int &ierr)
write Alignable original (before misalignment) absolute positions
Definition: AlignmentIORoot.cc:149
align::Correlations
std::map< std::pair< Alignable *, Alignable * >, AlgebraicMatrix > Correlations
Definition: Utilities.h:31
AlignmentIORoot::readAlignableOriginalPositions
AlignablePositions readAlignableOriginalPositions(const align::Alignables &alivec, const char *filename, int iter, int &ierr)
read Alignable original (before misalignment) absolute positions
Definition: AlignmentIORoot.cc:168
AlignmentParametersIORoot::open
int open(const char *filename, int iteration, bool writemode)
Open IO.
Definition: AlignmentParametersIORoot.h:32
AlignableShifts
std::vector< AlignableRelData > AlignableShifts
Definition: AlignableData.h:52
mps_fire.result
tuple result
Definition: mps_fire.py:95
AlignmentIORoot::writeCorrelations
void writeCorrelations(const align::Correlations &cormap, const char *filename, int iter, bool validCheck, int &ierr)
write Correlations
Definition: AlignmentIORoot.cc:69
AlignmentIORoot::readAlignableAbsolutePositions
AlignablePositions readAlignableAbsolutePositions(const align::Alignables &alivec, const char *filename, int iter, int &ierr)
read Alignable current absolute positions
Definition: AlignmentIORoot.cc:128
AlignmentParametersIO::writeOrigRigidBody
int writeOrigRigidBody(const align::Alignables &alivec, bool validCheck)
write original RigidBodyAlignmentParameters of many Alignables
Definition: AlignmentParametersIO.cc:50
AlignableDataIO::writeOrgPos
int writeOrgPos(Alignable *ali, bool validCheck)
Write original positions of one Alignable.
Definition: AlignableDataIO.cc:83
AlignableDataIORoot
concrete class for ROOT based IO of Alignable positions
Definition: AlignableDataIORoot.h:12
AlignmentIORoot::readCorrelations
align::Correlations readCorrelations(const align::Alignables &alivec, const char *filename, int iter, int &ierr)
read Correlations
Definition: AlignmentIORoot.cc:87
AlignmentParametersIO::read
align::Parameters read(const align::Alignables &alivec, int &ierr)
read AlignmentParameters of many Alignables
Definition: AlignmentParametersIO.cc:70
AlignableDataIO::writeRelPos
int writeRelPos(Alignable *ali, bool validCheck)
Write relative positions of one Alignable.
Definition: AlignableDataIO.cc:63
AlignmentIORoot::writeAlignableRelativePositions
void writeAlignableRelativePositions(const align::Alignables &alivec, const char *filename, int iter, bool validCheck, int &ierr)
write Alignable relative positions (shift,rotation)
Definition: AlignmentIORoot.cc:189
AlignableDataIO::readRelPos
AlignableRelData readRelPos(Alignable *ali, int &ierr)
Read relative positions of one Alignable.
Definition: AlignableDataIO.cc:24
AlignmentIORoot::writeAlignmentParameters
void writeAlignmentParameters(const align::Alignables &alivec, const char *filename, int iter, bool validCheck, int &ierr)
write AlignmentParameters
Definition: AlignmentIORoot.cc:12
AlignmentCorrelationsIORoot::open
int open(const char *filename, int iteration, bool writemode)
open IO
Definition: AlignmentCorrelationsIORoot.h:20
align::Alignables
std::vector< Alignable * > Alignables
Definition: Utilities.h:28
align::Parameters
std::vector< AlignmentParameters * > Parameters
Definition: Utilities.h:29
lut2db_cfg.filename
tuple filename
Definition: lut2db_cfg.py:20
AlignableDataIORoot::open
int open(const char *filename, int iteration, bool writemode)
open IO
Definition: AlignableDataIORoot.h:22
AlignablePositions
std::vector< AlignableAbsData > AlignablePositions
Definition: AlignableData.h:51
AlignmentCorrelationsIORoot::write
int write(const align::Correlations &cor, bool validCheck)
write correlations
Definition: AlignmentCorrelationsIORoot.cc:45
AlignmentIORoot::writeAlignableAbsolutePositions
void writeAlignableAbsolutePositions(const align::Alignables &alivec, const char *filename, int iter, bool validCheck, int &ierr)
write Alignable current absolute positions
Definition: AlignmentIORoot.cc:109
AlignmentIORoot::readAlignmentParameters
align::Parameters readAlignmentParameters(const align::Alignables &alivec, const char *filename, int iter, int &ierr)
read AlignmentParameters
Definition: AlignmentIORoot.cc:30
AlignmentIORoot::writeOrigRigidBodyAlignmentParameters
void writeOrigRigidBodyAlignmentParameters(const align::Alignables &alivec, const char *filename, int iter, bool validCheck, int &ierr)
write RigidBodyAlignmentParameters as applied on top of original positions
Definition: AlignmentIORoot.cc:52
AlignmentCorrelationsIORoot
Concrete class for ROOT based IO of Correlations.
Definition: AlignmentCorrelationsIORoot.h:10
AlignableDataIORoot::close
int close(void)
close IO
Definition: AlignableDataIORoot.h:26
Generated for CMSSW Reference Manual by doxygen 1.8.5