Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/g3tog4/src/clparse.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /g3tog4/src/clparse.cc (Version 11.3.0) and /g3tog4/src/clparse.cc (Version 4.1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: clparse.cc,v 1.14 2001/10/11 12:36:03 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-04-01 $
 27 //                                                 26 //
 28 // modified by I.Hrivnacova                        27 // modified by I.Hrivnacova
 29 // added G3SensVol                                 28 // added G3SensVol
 30                                                    29 
 31 #include "globals.hh"                              30 #include "globals.hh"
 32 #include <fstream>                             <<  31 #include "g4std/fstream"
 33 #include "G4Tokenizer.hh"                          32 #include "G4Tokenizer.hh"
 34 #include "G3toG4.hh"                               33 #include "G3toG4.hh"
 35 #include "G3EleTable.hh"                           34 #include "G3EleTable.hh"
 36 #include "G3VolTable.hh"                           35 #include "G3VolTable.hh"
 37 #include "G3MatTable.hh"                           36 #include "G3MatTable.hh"
 38 #include "G3MedTable.hh"                           37 #include "G3MedTable.hh"
 39 #include "G3RotTable.hh"                           38 #include "G3RotTable.hh"
 40 #include "G3PartTable.hh"                          39 #include "G3PartTable.hh"
 41 #include "G3DetTable.hh"                           40 #include "G3DetTable.hh"
 42 #include "G3SensVolVector.hh"                      41 #include "G3SensVolVector.hh"
 43                                                    42 
 44 std::ofstream ofile;                           <<  43 G4std::ofstream ofile;
 45                                                    44 
 46 extern "C"                                     <<  45 extern "C" {
 47 {                                              << 
 48 #include <stdlib.h>                                46 #include <stdlib.h>
 49 }                                                  47 }
 50                                                    48 
 51 extern std::ofstream ofile;                    <<  49 extern G4std::ofstream ofile;
 52                                                    50 
 53 G3VolTable G3Vol;                                  51 G3VolTable G3Vol;
 54 G3MatTable G3Mat;   // material G3 ID <-> G4 p <<  52 G3MatTable G3Mat; // material G3 ID <-> G4 pointer table
 55 G3MedTable G3Med;   // trk media G3 ID <-> G4  <<  53 G3MedTable G3Med; // trk media G3 ID <-> G4 pointer table
 56 G3RotTable G3Rot;   // rotation ID <-> G4 tran <<  54 G3RotTable G3Rot; // rotation ID <-> G4 transform object table
 57 G3PartTable G3Part; // particle ID <-> Particl     55 G3PartTable G3Part; // particle ID <-> ParticleDefinition pointer
 58 G3DetTable G3Det;   // sensitive detector name <<  56 G3DetTable G3Det; // sensitive detector name <-> pointer
 59 G3EleTable G3Ele;   // element names table     <<  57 G3EleTable G3Ele; // element names table
 60 G3SensVolVector G3SensVol; // vector of sensit     58 G3SensVolVector G3SensVol; // vector of sensitive logical volumes
 61 char gSeparator('_');                          << 
 62                                                    59 
 63 G4int narray;                                      60 G4int narray;
 64                                                    61 
 65 G4int Ipar[1000];                                  62 G4int Ipar[1000];
 66 G4double Rpar[1000];                               63 G4double Rpar[1000];
 67 G4String Spar[1000];                               64 G4String Spar[1000];
 68                                                    65 
 69 G4int G3CLTokens(G4String *line, G4String *tok     66 G4int G3CLTokens(G4String *line, G4String *tokens);
 70 void G3CLEval(G4String *tokens, char *select);     67 void G3CLEval(G4String *tokens, char *select);
 71                                                    68 
 72 // front-end decoders for G3 routines              69 // front-end decoders for G3 routines
 73 //                                             << 
 74 void PG4gsvolu(G4String *tokens);                  70 void PG4gsvolu(G4String *tokens);
 75 void PG4gspos (G4String *tokens);                  71 void PG4gspos (G4String *tokens);
 76 void PG4gsposp(G4String *tokens);                  72 void PG4gsposp(G4String *tokens);
 77 void PG4gsatt (G4String *tokens);                  73 void PG4gsatt (G4String *tokens);
 78 void PG4gsrotm(G4String *tokens);                  74 void PG4gsrotm(G4String *tokens);
 79 void PG4gsdvn (G4String *tokens);                  75 void PG4gsdvn (G4String *tokens);
 80 void PG4gsdvt (G4String *tokens);                  76 void PG4gsdvt (G4String *tokens);
 81 void PG4gsdvx (G4String *tokens);                  77 void PG4gsdvx (G4String *tokens);
 82 void PG4gsdvn2(G4String *tokens);                  78 void PG4gsdvn2(G4String *tokens);
 83 void PG4gsdvt2(G4String *tokens);                  79 void PG4gsdvt2(G4String *tokens);
 84 void PG4gsmate(G4String *tokens);                  80 void PG4gsmate(G4String *tokens);
 85 void PG4gsmixt(G4String *tokens);                  81 void PG4gsmixt(G4String *tokens);
 86 void PG4gstmed(G4String *tokens);                  82 void PG4gstmed(G4String *tokens);
 87 void PG4gstpar(G4String *tokens);                  83 void PG4gstpar(G4String *tokens);
 88 void PG4gspart(G4String *tokens);                  84 void PG4gspart(G4String *tokens);
 89 void PG4gsdk  (G4String *tokens);                  85 void PG4gsdk  (G4String *tokens);
 90 void PG4gsdet (G4String *tokens);                  86 void PG4gsdet (G4String *tokens);
 91 void PG4gsdetv(G4String *tokens);                  87 void PG4gsdetv(G4String *tokens);
 92 void PG4gsdeta(G4String *tokens);                  88 void PG4gsdeta(G4String *tokens);
 93 void PG4gsdeth(G4String *tokens);                  89 void PG4gsdeth(G4String *tokens);
 94 void PG4gsdetd(G4String *tokens);                  90 void PG4gsdetd(G4String *tokens);
 95 void PG4gsdetu(G4String *tokens);                  91 void PG4gsdetu(G4String *tokens);
 96 void PG4ggclos();                                  92 void PG4ggclos();
 97                                                    93 
 98 void G3CLRead(G4String & fname, char *select = <<  94 void G3CLRead(G4String & fname, char *select = 0){
 99 {                                              <<  95 //
100   //                                           <<  96 //  G3CLRead
101   //  G3CLRead                                 <<  97 //  Read the call List file, parse the tokens, and pass the token
102   //  Read the call List file, parse the token <<  98 //  List to the Geant4 interpreter
103   //  List to the Geant4 interpreter           <<  99 //
104   //                                           << 100 //  fname: call List filename
105   //  fname: call List filename                << 101 //
106                                                   102   
107     G4String line;                             << 103   G4String line;
108     G4String tokens[1000];                     << 104   G4String tokens[1000];
109                                                   105 
110     const char* ofname = "clparse.out";        << 106   const char* ofname = "clparse.out";
111     ofile.open(ofname);                        << 107   ofile.open(ofname);
112     ofile << "Output file open\n";             << 108   ofile << "Output file open\n";
113                                                << 109 
114     G4int ntokens = 0;                         << 110   G4int count = 0;
115     std::ifstream istr(fname);                 << 111   G4int ntokens = 0;
                                                   >> 112   G4std::ifstream istr(fname);
116                                                   113     
117     while (G4StrUtil::readline(istr, line) &&  << 114   while (line.readLine(istr) && ! istr.eof()){
118     {                                          << 115       count++;
119         ntokens = G3CLTokens(&line,tokens);  / << 116       ntokens = G3CLTokens(&line,tokens);  // tokenize the line
120         for (G4int i=0; i < ntokens; i++)      << 117       for (G4int i=0; i < ntokens; i++) ofile << tokens[i] << G4endl;
121         {                                      << 118       
122           ofile << tokens[i] << G4endl;        << 119           // interpret the line as a Geant call
123         }                                      << 120       G3CLEval(tokens, select);
124                                                << 121   }
125         // interpret the line as a Geant call  << 
126         //                                     << 
127         G3CLEval(tokens, select);              << 
128     }                                          << 
129 }                                                 122 }
130                                                   123 
131                                                   124 
132 G4int G3CLTokens(G4String *line, G4String toke    125 G4int G3CLTokens(G4String *line, G4String tokens[])
                                                   >> 126 //
                                                   >> 127 // G3CLTokens
                                                   >> 128 //
                                                   >> 129 // Tokenize line, returning tokens in tokens[]. Items in ".."
                                                   >> 130 // are extracted as single tokens, despite embedded spaces.
                                                   >> 131 //
133 {                                                 132 {
134   //                                           << 
135   // G3CLTokens                                << 
136   //                                           << 
137   // Tokenize line, returning tokens in tokens << 
138   // are extracted as single tokens, despite e << 
139                                                << 
140     G4Tokenizer next(*line);                      133     G4Tokenizer next(*line);
141                                                << 
142     // first tokenize using " to identify stri    134     // first tokenize using " to identify strings
143     //                                         << 
144     G4int itok = 0;                               135     G4int itok = 0;
145     G4int ntokens = 0;                            136     G4int ntokens = 0;
146     G4String token1, token2;                      137     G4String token1, token2;
147     while (!(token1=next("\"")).empty())       << 138     while (!(token1=next("\"")).isNull())
148     {                                          << 
149         itok++;                                << 
150         if (itok%2 == 0 ) // even: inside a st << 
151         {                                      << 
152             tokens[ntokens++] = token1;        << 
153         }                                      << 
154         else              // not in a quoted s << 
155         {                                         139         {
156             G4Tokenizer lev2(token1);          << 140             itok++;
157             while (!(token2=lev2()).empty())   << 141             if (itok%2 == 0 ) // even: inside a string
158             {                                  << 142                 {
159                 tokens[ntokens] = token2;      << 143                     tokens[ntokens++] = token1;
160                 ntokens++;                     << 144                 } else        // not in a quoted string: finish tokenization
161             }                                  << 145                 {
                                                   >> 146                     G4Tokenizer lev2(token1);
                                                   >> 147                     while (!(token2=lev2()).isNull())
                                                   >> 148                         {
                                                   >> 149                             tokens[ntokens] = token2;
                                                   >> 150                             ntokens++;
                                                   >> 151                         }
                                                   >> 152                 }
162         }                                         153         }
163     }                                          << 
164     return ntokens;                               154     return ntokens;
165 }                                                 155 }
166                                                   156 
167                                                << 
168 void G3CLEval(G4String tokens[], char *select)    157 void G3CLEval(G4String tokens[], char *select)
                                                   >> 158 //
                                                   >> 159 // G3CLEval
                                                   >> 160 //
                                                   >> 161 // Evaluate the token List as a Geant3 call, and execute it as
                                                   >> 162 // a Geant4 call.
                                                   >> 163 //
169 {                                                 164 {
170   //                                           << 
171   // G3CLEval                                  << 
172   //                                           << 
173   // Evaluate the token List as a Geant3 call, << 
174   // a Geant4 call.                            << 
175                                                << 
176     const char* context = tokens[0];              165     const char* context = tokens[0];
177     const char* routine = tokens[1];              166     const char* routine = tokens[1];
178     const char* wcard = "*";                   << 
179                                                   167 
180     // If context is selected, return unless c << 168     // If context is selected, return unless context matches.
181     //                                         << 169     if (select != 0 && select != "*") if ( strcmp(select,context) ) return;
182     if ((select != 0) && (select != wcard))    << 
183     {                                          << 
184       if ( strcmp(select,context) )  { return; << 
185     }                                          << 
186                                                   170 
187     // Branch on Geant3 routine name              171     // Branch on Geant3 routine name
188     //                                         << 
189     ofile << "Do routine " << routine << " in     172     ofile << "Do routine " << routine << " in context " << context << G4endl;
190                                                   173     
191     if ( !strcmp(routine,"GSVOLU") ) { PG4gsvo << 174     if ( !strcmp(routine,"GSVOLU") ) { 
                                                   >> 175 //      volcount++;
                                                   >> 176 //      if (volcount == 1) {
                                                   >> 177 //        // Special handling of the first one, assumed to be global mother
                                                   >> 178 //        if ( GlobalMotherVolume == 0 ) {
                                                   >> 179 //        PG4gsvolu(&tokens[2]); 
                                                   >> 180 //        } else {
                                                   >> 181 //          G4String gblmoth="Global mother";
                                                   >> 182 //          G3Vol.PutLV(&gblmoth,GlobalMotherVolume);
                                                   >> 183 //        }
                                                   >> 184 //      } else {
                                                   >> 185 //        PG4gsvolu(&tokens[2]); 
                                                   >> 186 //      }
                                                   >> 187 //      if (volcount == 2) {
                                                   >> 188 //        G4String vname = tokens[2];
                                                   >> 189 //        SubsystemMotherVolume = G3Vol.GetLV(&vname);
                                                   >> 190 //      }
                                                   >> 191         { PG4gsvolu(&tokens[2]); return;}
                                                   >> 192     }
192     if ( !strcmp(routine,"GSPOS") )  { PG4gspo    193     if ( !strcmp(routine,"GSPOS") )  { PG4gspos (&tokens[2]); return;}
193     if ( !strcmp(routine,"GSPOSP") ) { PG4gspo    194     if ( !strcmp(routine,"GSPOSP") ) { PG4gsposp(&tokens[2]); return;}
194     if ( !strcmp(routine,"GSATT") )  { PG4gsat    195     if ( !strcmp(routine,"GSATT") )  { PG4gsatt (&tokens[2]); return;}
195     if ( !strcmp(routine,"GSROTM") ) { PG4gsro    196     if ( !strcmp(routine,"GSROTM") ) { PG4gsrotm(&tokens[2]); return;}
196     if ( !strcmp(routine,"GSDVN") )  { PG4gsdv    197     if ( !strcmp(routine,"GSDVN") )  { PG4gsdvn (&tokens[2]); return;}
197     if ( !strcmp(routine,"GSDVT") )  { PG4gsdv    198     if ( !strcmp(routine,"GSDVT") )  { PG4gsdvt (&tokens[2]); return;}
198     if ( !strcmp(routine,"GSDVX") )  { PG4gsdv    199     if ( !strcmp(routine,"GSDVX") )  { PG4gsdvx (&tokens[2]); return;}
199     if ( !strcmp(routine,"GSDVN2") ) { PG4gsdv    200     if ( !strcmp(routine,"GSDVN2") ) { PG4gsdvn2(&tokens[2]); return;}
200     if ( !strcmp(routine,"GSDVT2") ) { PG4gsdv    201     if ( !strcmp(routine,"GSDVT2") ) { PG4gsdvt2(&tokens[2]); return;}
201     if ( !strcmp(routine,"GSMATE") ) { PG4gsma    202     if ( !strcmp(routine,"GSMATE") ) { PG4gsmate(&tokens[2]); return;}
202     if ( !strcmp(routine,"GSMIXT") ) { PG4gsmi    203     if ( !strcmp(routine,"GSMIXT") ) { PG4gsmixt(&tokens[2]); return;}
203     if ( !strcmp(routine,"GSTMED") ) { PG4gstm    204     if ( !strcmp(routine,"GSTMED") ) { PG4gstmed(&tokens[2]); return;}
204     if ( !strcmp(routine,"GSTPAR") ) { PG4gstp    205     if ( !strcmp(routine,"GSTPAR") ) { PG4gstpar(&tokens[2]); return;}
205     if ( !strcmp(routine,"GSPART") ) { PG4gspa    206     if ( !strcmp(routine,"GSPART") ) { PG4gspart(&tokens[2]); return;}
206     if ( !strcmp(routine,"GSDK") )   { PG4gsdk    207     if ( !strcmp(routine,"GSDK") )   { PG4gsdk  (&tokens[2]); return;}
207     if ( !strcmp(routine,"GSDET") )  { PG4gsde    208     if ( !strcmp(routine,"GSDET") )  { PG4gsdet (&tokens[2]); return;}
208     if ( !strcmp(routine,"GSDETV") ) { PG4gsde    209     if ( !strcmp(routine,"GSDETV") ) { PG4gsdetv(&tokens[2]); return;}
209     if ( !strcmp(routine,"GSDETA") ) { PG4gsde    210     if ( !strcmp(routine,"GSDETA") ) { PG4gsdeta(&tokens[2]); return;}
210     if ( !strcmp(routine,"GSDETH") ) { PG4gsde    211     if ( !strcmp(routine,"GSDETH") ) { PG4gsdeth(&tokens[2]); return;}
211     if ( !strcmp(routine,"GSDETD") ) { PG4gsde    212     if ( !strcmp(routine,"GSDETD") ) { PG4gsdetd(&tokens[2]); return;}
212     if ( !strcmp(routine,"GSDETU") ) { PG4gsde    213     if ( !strcmp(routine,"GSDETU") ) { PG4gsdetu(&tokens[2]); return;}
213     if ( !strcmp(routine,"GGCLOS") ) { PG4ggcl    214     if ( !strcmp(routine,"GGCLOS") ) { PG4ggclos(); return;}
214 }                                                 215 }
215                                                   216 
216 void G3fillParams(G4String *tokens, const char    217 void G3fillParams(G4String *tokens, const char *ptypes)
                                                   >> 218 //
                                                   >> 219 // G3fillParams
                                                   >> 220 //
                                                   >> 221 // Interpret tokens to fill call parameters, based on parameter
                                                   >> 222 //   types ptypes
                                                   >> 223 //
217 {                                                 224 {
218   //                                           << 
219   // G3fillParams                              << 
220   //                                           << 
221   // Interpret tokens to fill call parameters, << 
222                                                << 
223     // loop over ptypes                           225     // loop over ptypes
224     //                                         << 
225     G4int i =0, ipt = 0, k = 0;                   226     G4int i =0, ipt = 0, k = 0;
226     G4int ni =0, nr = 0, nq = 0;               << 227     G4int ni =0, nr = 0, ns = 0;
227     while (ptypes[i] != '\0')                     228     while (ptypes[i] != '\0')
228     {                                          << 
229         switch (ptypes[i])                     << 
230         {                                         229         {
                                                   >> 230             switch (ptypes[i]) {
231             case 'i':                             231             case 'i':
232                 Ipar[ni] = atoi(tokens[ipt].da    232                 Ipar[ni] = atoi(tokens[ipt].data());
233                 narray = Ipar[ni];                233                 narray = Ipar[ni];
234                 ni++; ipt++;                      234                 ni++; ipt++;
235                 break;                            235                 break;
236             case 'r':                             236             case 'r':
237                 Rpar[nr] = atof(tokens[ipt].da    237                 Rpar[nr] = atof(tokens[ipt].data());
238                 nr++; ipt++;                      238                 nr++; ipt++;
239                 break;                            239                 break;
240             case 's':                             240             case 's':
241                 Spar[nq] = tokens[ipt];        << 241                 Spar[ns] = tokens[ipt];
242                 nq++; ipt++;                   << 242                 ns++; ipt++;
243                 break;                            243                 break;
244             case 'I':                             244             case 'I':
245                 for (k=0; k < narray; k++)        245                 for (k=0; k < narray; k++)
246                 {                              << 246                     {
247                     Ipar[ni] = atoi(tokens[ipt << 247                         Ipar[ni] = atoi(tokens[ipt].data());
248                     ni++; ipt++;               << 248                         ni++; ipt++;
249                 }                              << 249                     }
250                 break;                            250                 break;
251             case 'R':                             251             case 'R':
252                 for (k=0; k < narray; k++)        252                 for (k=0; k < narray; k++) 
253                 {                              << 253                     { 
254                     Rpar[nr] = atof(tokens[ipt << 254                         Rpar[nr] = atof(tokens[ipt].data()); 
255                     nr++; ipt++;               << 255                         nr++; ipt++;
256                 }                              << 256                     }
257                 break;                            257                 break;
258             case 'Q':                             258             case 'Q':
259                 // special case of reading thr    259                 // special case of reading three successive R arrays 
260                 // into one (used in gsmixt)      260                 // into one (used in gsmixt)
261                 //                             << 261                 narray = 3 * abs(narray);
262                 narray = 3 * std::abs(narray); << 
263                 for (k=0; k < narray; k++)        262                 for (k=0; k < narray; k++) 
264                 {                              << 263                     { 
265                     Rpar[nr] = atof(tokens[ipt << 264                         Rpar[nr] = atof(tokens[ipt].data()); 
266                     nr++; ipt++;               << 265                         nr++; ipt++;
267                 }                              << 266                     }
268                 break;                            267                 break;
269             case 'S':                             268             case 'S':
270                 for (k=0; k < narray; k++)        269                 for (k=0; k < narray; k++)
271                 {                              << 270                     {
272                     Spar[nq] = tokens[ipt];    << 271                         Spar[ns] = tokens[ipt];
273                     nq++; ipt++;               << 272                         ns++; ipt++;
274                 }                              << 273                     }
275                 break;                            274                 break;
276             default:                              275             default:
277                 ofile << "unidentified ptype '    276                 ofile << "unidentified ptype '" << ptypes[i] << G4endl;
278         };                                     << 277             };
279         i++;                                   << 278             i++;
280     }                                          << 279         }
281 }                                                 280 }
282                                                   281