Ignore:
Timestamp:
10/12/04 14:43:18 (20 years ago)
Author:
moralejo
Message:
*** empty log message ***
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Simulation/Detector/StarResponse/MStarLight.cxx

    r5099 r5248  
    33using namespace std;
    44
    5 MStarLight::MStarLight() {
     5MStarLight::MStarLight(Float_t fadc_slices_per_ns, Int_t response_slices_fadc) {
    66  //
    77  //   default constructor
    88  //
    99
     10  fBrightness  = 0.;
     11  fTimeRange   = TIMERANGE;
     12
     13  fFadcSlicesPerNanosec = fadc_slices_per_ns; // "real" number of FADC slices per ns
     14
     15  fResponseSlicesFadc = response_slices_fadc;
     16  // total number of bins in the histogram containing the response of the FADC to a
     17  // single photoelectron. The bins are narrower than the true FADC slices by a factor
     18  // equal to SUBBINS (see MFadcDefine.h)
     19
     20
     21  fBinsTrig = (Int_t)(TRIG_SLICES_PER_NSEC*TIMERANGE);   // Default value 4*10000=40000
     22  fTrigShape   = 0;
     23  fAmplTrig    = 0.;
     24  fFwhmTrig    = 0.;
     25
     26  fBinsFadc    = (Int_t)(fFadcSlicesPerNanosec*TIMERANGE);  // Default value 0.3*10000=3000
     27  fFadcShape   = 0;
     28  fIntegFadc   = 0.;
     29  fFwhmFadc    = 0.;
     30
     31
     32  fTrig     = new Float_t[fBinsTrig];
     33  fTrigResp = new Float_t[RESPONSE_SLICES_TRIG];
     34  fFadc     = new Float_t[fBinsFadc];
     35  fFadcResp = new Float_t[fResponseSlicesFadc];
     36 
     37  for (Int_t i= 0; i< fBinsTrig ; i++)
     38    fTrig[i] = 0. ;
     39
     40  for (Int_t i= 0; i < fBinsFadc; i++)
     41    fFadc[i] = 0.;
     42 
     43  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     44    fTrigResp[i] = 0.;
     45
     46  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     47    fFadcResp[i] = 0.;
     48}
     49
     50void MStarLight::Reset() {
     51
     52 
    1053  fBrightness  = 0. ;
    11   fTimeRange   = TIMERANGE  ;
    12 
    13   fBinsTrig    = TRIGBINS   ;
    14   fTrigShape   = 0. ;
    15   fAmplTrig    = 0. ;
    16   fFwhmTrig    = 0. ;
    17 
    18   fBinsFadc    = FADCBINS   ;
    19   fFadcShape   = 0. ;
    20   fIntegFadc    = 0. ;
    21   fFwhmFadc    = 0. ;
    22 
    23  
    24   for (Int_t i= 0; i< TRIGBINS ; i++)
    25     fTrig[i] = 0. ;
    26 
    27   for (Int_t i= 0; i<FADCBINS; i++)
    28     fFadc[i] = 0. ;
    29  
    30   for (Int_t i= 0; i<40; i++)
    31     fTrigResp[i] = 0. ;
    32 
    33   for (Int_t i= 0; i<45; i++)
    34     fFadcResp[i] = 0. ;
    35 }
    36 
    37 void MStarLight::Reset() {
    38 
    39  
    40   fBrightness  = 0. ;
    41   fTimeRange   = TIMERANGE  ;
    42 
    43   fBinsTrig    = TRIGBINS   ;
    44   fTrigShape   = 0. ;
    45   fAmplTrig    = 0. ;
    46   fFwhmTrig    = 0. ;
    47 
    48   fBinsFadc    = FADCBINS   ;
    49   fFadcShape   = 0. ;
    50   fIntegFadc    = 0. ;
    51   fFwhmFadc    = 0. ;
    52 
    53  
    54   for (Int_t i= 0; i< TRIGBINS ; i++)
    55     fTrig[i] = 0. ;
    56 
    57   for (Int_t i= 0; i<FADCBINS; i++)
    58     fFadc[i] = 0. ;
    59  
    60   for (Int_t i= 0; i<40; i++)
    61     fTrigResp[i] = 0. ;
    62 
    63   for (Int_t i= 0; i<45; i++)
    64     fFadcResp[i] = 0. ;
    65 }
    66 
    67 
     54  fTimeRange   = TIMERANGE;
     55
     56  fTrigShape   = 0;
     57  fAmplTrig    = 0.;
     58  fFwhmTrig    = 0.;
     59
     60  fFadcShape   = 0;
     61  fIntegFadc   = 0.;
     62  fFwhmFadc    = 0.;
     63
     64 
     65  for (Int_t i= 0; i < fBinsTrig ; i++)
     66    fTrig[i] = 0.;
     67
     68  for (Int_t i= 0; i < fBinsFadc; i++)
     69    fFadc[i] = 0.;
     70 
     71  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     72    fTrigResp[i] = 0.;
     73
     74  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     75    fFadcResp[i] = 0.;
     76}
    6877
    6978Float_t MStarLight::GetBrightness ()
    7079{
    71   return fBrightness  ;
     80  return fBrightness;
    7281}
    7382
    7483void MStarLight::SetBrightness (Float_t in )
    7584{
    76   fBrightness = in ;
     85  fBrightness = in;
    7786}
    7887
    7988Float_t MStarLight::GetAmplTrig ()
    8089{
    81   return fAmplTrig  ;
     90  return fAmplTrig ;
    8291}
    8392
    8493void MStarLight::SetAmplTrig (Float_t in )
    8594{
    86   fAmplTrig = in ;
     95  fAmplTrig = in;
    8796}
    8897
    8998Float_t  MStarLight::GetFwhmTrig ()
    9099{
    91   return fFwhmTrig  ;
     100  return fFwhmTrig;
    92101}
    93102
    94103void MStarLight::SetFwhmTrig (Float_t in )
    95104{
    96   fFwhmTrig = in ;
    97 }
    98 
     105  fFwhmTrig = in;
     106}
     107
     108void MStarLight::SetFadcSlicesPerNanosec (Float_t in)
     109{
     110  fFadcSlicesPerNanosec = in;
     111  fBinsFadc    = (Int_t)(fFadcSlicesPerNanosec*TIMERANGE);
     112
     113  if (fFadc)
     114    delete [] fFadc;
     115
     116  fFadc = new Float_t[fBinsFadc];
     117
     118  for (Int_t i= 0; i < fBinsFadc; i++)
     119    fFadc[i] = 0.; 
     120}
    99121
    100122Float_t MStarLight::GetIntegFadc ()
    101123{
    102   return fIntegFadc  ;
     124  return fIntegFadc;
    103125}
    104126
    105127void MStarLight::SetIntegFadc (Float_t in )
    106128{
    107   fIntegFadc = in ;
     129  fIntegFadc = in;
    108130}
    109131
    110132Float_t  MStarLight::GetFwhmFadc ()
    111133{
    112   return fFwhmFadc  ;
     134  return fFwhmFadc;
    113135}
    114136
    115137void MStarLight::SetFwhmFadc (Float_t in )
    116138{
    117   fFwhmFadc = in ;
    118 }
    119 
    120 
    121 void MStarLight::SetTrigResponse( Float_t *in ) {
    122  
    123   for (Int_t i= 0; i<40; i++)
    124     fTrigResp[i] = in[i] ;
    125  
    126 }
    127 
    128 void MStarLight::SetFadcResponse( Float_t *in ) {
    129 
    130   for (Int_t i= 0; i<45; i++)
    131     fFadcResp[i] = in[i] ;
    132 }
    133 
    134 void MStarLight::FillResponse( Float_t ampl, Float_t time ) {
    135 
    136   //     fill the trigger response
    137  
    138   Int_t startbin = (Int_t) (time * 4)  ;
    139  
    140   Int_t icount = 0 ;
    141   Int_t idata      ;
    142  
    143   for ( Int_t i=startbin ; i<startbin+40 ; i++) {
    144     //
    145     if ( i < TRIGBINS )
    146       idata = i ;
    147     else if ( i >= TRIGBINS )
    148       idata = i - TRIGBINS ;
    149 
    150     fTrig[idata] = fTrig[idata] + ampl * fTrigResp[icount] ;
    151    
    152     icount++ ;
    153   }
     139  fFwhmFadc = in;
     140}
     141
     142
     143void MStarLight::SetTrigResponse( Float_t *in )
     144{
     145  for (Int_t i = 0; i < RESPONSE_SLICES_TRIG; i++)
     146    fTrigResp[i] = in[i];
     147}
     148
     149void MStarLight::SetFadcResponse( Float_t *in )
     150{
     151  for (Int_t i = 0; i < fResponseSlicesFadc; i++)
     152    fFadcResp[i] = in[i];
     153}
     154
     155void MStarLight::FillResponse( Float_t ampl, Float_t time )
     156{
     157  //  fill the trigger response
     158 
     159  Int_t startbin = (Int_t) (time * ((Float_t)fBinsTrig/TIMERANGE));
     160
     161  Int_t icount = 0;
     162  Int_t idata;
     163 
     164  for ( Int_t i = startbin ; i < startbin+RESPONSE_SLICES_TRIG ; i++)
     165    {
     166      if ( i < fBinsTrig )
     167        idata = i;
     168      else if ( i >= fBinsTrig )
     169        idata = i - fBinsTrig;
     170
     171      fTrig[idata] = fTrig[idata] + ampl * fTrigResp[icount];
     172      icount++ ;
     173    }
    154174
    155175  //
    … …  
    157177  //
    158178
    159   startbin = (Int_t) ( time / 0.6666666666 );
    160  
     179  startbin = (Int_t) ( time * ((Float_t)(fBinsFadc*SUBBINS)/TIMERANGE));
     180
    161181  Int_t ichanfadc = 0 ;
    162182 
    163183  //
    164184  //   putting the response slices in the right sig slices.
    165   //   Be carefull, because both slices have different widths.
     185  //   Be careful, because both slices have different widths.
    166186  //
    167187
    … …  
    170190  // the signal within each FADC slice, but measures just the signal height
    171191  // at one point, like the real FADC does. By default, each FADC slice
    172   // contains 5 bins of the response histogram(fFadcResp[45]). Warning:
    173   // do not change this unless you do the corresponding modifications also
    174   // in MFadc.cxx, or the signal and the noise photoelectrons will be treated
    175   // differently!!
    176   //
    177 
    178   for ( Int_t i = 0 ; i < 45; i += 5 ) {
    179     ichanfadc = (Int_t) ((startbin+i)/5) ;
    180    
    181     if ( (ichanfadc) < FADCBINS )
    182       idata = ichanfadc ;
    183     else if ( ichanfadc >=FADCBINS )
    184       idata = ichanfadc-FADCBINS ;
    185    
    186     fFadc[idata] += (ampl * fFadcResp[i] )  ;
    187    
    188   }
    189 
     192  // contains SUBBINS bins of the response histogram
     193  // (fFadcResp). Warning: do not change this unless you do the corresponding
     194  // modifications also in MFadc.cxx, or the signal and the noise photoelectrons
     195  // will be treated differently!!
     196  //
     197
     198  for ( Int_t i = 0 ; i < fResponseSlicesFadc; i += SUBBINS )
     199    {
     200      ichanfadc = (Int_t) ((startbin+i)/(Float_t)SUBBINS);
     201
     202      if ( ichanfadc < fBinsFadc )
     203        idata = ichanfadc;
     204      else if ( ichanfadc >= fBinsFadc )
     205        idata = ichanfadc-fBinsFadc;
     206
     207      fFadc[idata] += (ampl * fFadcResp[i]);
     208    }
    190209}
    191210
    … …  
    197216  TRandom2 wuerfel( (UInt_t) (noiseTrig*100) ) ;
    198217 
    199   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    200     fTrig[i] += wuerfel.Gaus(0., noiseTrig ) ;
    201   }
    202 
    203   for (Int_t i=0; i< FADCBINS ; i++ ) {
    204     fFadc[i] += wuerfel.Gaus(0., noiseFadc ) ;
    205   }
    206  
    207  
    208 }
    209 
    210 Float_t MStarLight::GetTrig( Int_t i){
     218  for (Int_t i=0; i< fBinsTrig ; i++ )
     219    fTrig[i] += wuerfel.Gaus(0., noiseTrig );
     220
     221  for (Int_t i=0; i< fBinsFadc ; i++ )
     222    fFadc[i] += wuerfel.Gaus(0., noiseFadc );
     223 
     224}
     225
     226Float_t MStarLight::GetTrig( Int_t i)
     227{
    211228  //------------------------------------------------------------------
    212229  //
    213   //  It gets the value of the simualted trigger in the i bin
     230  //  It gets the value of the simulated trigger in the i bin
    214231  //
    215232  return fTrig[i];
    216233}
    217234
    218 Float_t MStarLight::GetFadc( Int_t i){
     235Float_t MStarLight::GetFadc( Int_t i)
     236{
    219237  //------------------------------------------------------------------
    220238  //
    221   //  It gets the value of the simualted FADC signal in the i bin
     239  //  It gets the value of the simulated FADC signal in the i bin
    222240  //
    223241  return fFadc[i];
    224242}
    225243
    226 void MStarLight::StoreHisto( char *filename) {
    227  
    228   Float_t baseline = 0. ;
    229 
    230 
    231   //    first the histogramms for trigger
     244void MStarLight::StoreHisto( char *filename)
     245{
     246
     247  Float_t baseline = 0.;
     248
     249  //    first the histograms for trigger
    232250  //
    233251  //    the calculated trigger signal before baseline
    234252  //
    235253
    236   TH1F  trigresp ("trigresp", "Trigger Response", TRIGBINS, 0., TIMERANGE) ;
    237 
    238   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    239    
    240     trigresp.SetBinContent(i, fTrig[i]) ;
    241 
    242     baseline = baseline + fTrig[i]  ;
    243   }
    244 
    245   baseline = baseline / TRIGBINS ;
     254  TH1F  trigresp ("trigresp", "Trigger Response", fBinsTrig, 0., TIMERANGE);
     255
     256  for (Int_t i=0; i< fBinsTrig ; i++ )
     257    {
     258      trigresp.SetBinContent(i+1, fTrig[i]);
     259      baseline += fTrig[i];
     260    }
     261
     262  baseline /= fBinsTrig;
    246263 
    247264  TH1F  trigbase ("trigbase", "Response after Baseline shift",
    248                   TRIGBINS, 0., TIMERANGE) ;
    249   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    250    
    251     trigbase.SetBinContent(i, fTrig[i]-baseline ) ;
    252    
    253   }
     265                  fBinsTrig, 0., TIMERANGE) ;
     266
     267  for (Int_t i = 0; i < fBinsTrig ; i++)
     268    trigbase.SetBinContent(i+1, fTrig[i]-baseline );
    254269 
    255270  TH1F  trigdist ("trigdist", "Noise on the baseline",
    256                   1000, -25., 25. ) ;
    257 
    258   for (Int_t i=0; i< TRIGBINS ; i++ ) {
    259    
    260     trigdist.Fill( (Float_t) trigbase.GetBinContent(i) ) ;
    261   }
     271                  1000, -25., 25. );
     272
     273  for (Int_t i = 0; i < fBinsTrig ; i++)
     274    trigdist.Fill( (Float_t) trigbase.GetBinContent(i+1) );
    262275
    263276
    264277  //
    265   //     second the histograms for the fadc
    266   //
    267  
    268  
    269   TH1F  fadcresp ("fadcresp", "Fadc Response", FADCBINS, 0., TIMERANGE) ;
    270 
    271   for (Int_t i=0; i< FADCBINS ; i++ ) {
    272    
    273     fadcresp.SetBinContent(i, fFadc[i]) ;
    274 
    275     baseline = baseline + fFadc[i]  ;
    276   }
    277 
    278   baseline = baseline / FADCBINS ;
     278  // Now the histograms for the fadc
     279  //
     280
     281  TH1F  fadcresp ("fadcresp", "Fadc Response", fBinsFadc, 0., TIMERANGE);
     282
     283  baseline = 0.;
     284  for (Int_t i=0; i < fBinsFadc; i++)
     285    {
     286      fadcresp.SetBinContent(i+1, fFadc[i]);
     287      baseline += fFadc[i];
     288    }
     289
     290  baseline /= fBinsFadc;
    279291 
    280292  TH1F  fadcbase ("fadcbase", "Fadc after Baseline shift",
    281                   FADCBINS, 0., TIMERANGE) ;
    282   for (Int_t i=0; i< FADCBINS ; i++ ) {
    283    
    284     fadcbase.SetBinContent(i, fFadc[i]-baseline ) ;
    285    
    286   }
    287  
     293                  fBinsFadc, 0., TIMERANGE) ;
     294
     295  for (Int_t i=0; i< fBinsFadc ; i++ )
     296    fadcbase.SetBinContent(i+1, fFadc[i]-baseline );
     297
    288298  TH1F  fadcdist ("fadcdist", "Noise on fadc",
    289299                  1000, -100., 100. ) ;
    290300
    291   for (Int_t i=0; i< FADCBINS ; i++ ) {
    292    
    293     fadcdist.Fill( (Float_t) fadcbase.GetBinContent(i) ) ;
    294   }
    295 
    296 
    297 
    298  
    299   TFile outfile( filename, "UPDATE" ) ;
    300  
    301   trigresp.Write() ;
    302   trigbase.Write() ;
    303   trigdist.Write() ;
    304 
    305   fadcresp.Write() ;
    306   fadcbase.Write() ;
    307   fadcdist.Write() ;
    308  
    309  
    310   outfile.Close() ;
    311 }
    312 
    313 void MStarLight::WriteBinary( char *filename) {
    314   //
    315   //  write the things to the binary file
     301  for (Int_t i=0; i< fBinsFadc ; i++ )
     302    fadcdist.Fill( (Float_t) fadcbase.GetBinContent(i+1) );
     303
     304  TFile outfile( filename, "RECREATE");
     305 
     306  trigresp.Write();
     307  trigbase.Write();
     308  trigdist.Write();
     309
     310  fadcresp.Write();
     311  fadcbase.Write();
     312  fadcdist.Write();
     313 
     314 
     315  outfile.Close();
     316}
     317
     318void MStarLight::WriteBinary( char *filename)
     319{
     320  //
     321  //  write the information to the binary file
    316322
    317323  FILE *datei ;
    … …  
    319325  datei = fopen ( filename, "w" ) ;
    320326 
    321   if ( ! datei ) {
    322     cout << " ERROR: Can't open the file " << filename
    323          << endl ;
    324     exit (230) ;
    325   }
     327  if ( ! datei )
     328    {
     329      cout << " ERROR: Can't open the file " << filename << endl;
     330      exit (230);
     331    }
    326332
    327333  Float_t version = VERSIONSR;
    … …  
    329335  //   write them out
    330336
    331   fwrite ( &version, sizeof(Float_t), 1, datei ) ;
    332   fwrite ( &fBrightness, sizeof(Float_t), 1, datei ) ;
    333   fwrite ( &fTimeRange , sizeof(Float_t), 1, datei ) ;
    334 
    335   fwrite ( &fBinsTrig  , sizeof(Float_t), 1, datei ) ;
    336   fwrite ( &fTrigShape , sizeof(Float_t), 1, datei ) ;
    337   fwrite ( &fAmplTrig  , sizeof(Float_t), 1, datei ) ;
    338   fwrite ( &fFwhmTrig  , sizeof(Float_t), 1, datei ) ;
    339 
    340   fwrite ( &fBinsFadc  , sizeof(Float_t), 1, datei ) ;
    341   fwrite ( &fFadcShape , sizeof(Float_t), 1, datei ) ;
    342   fwrite ( &fIntegFadc , sizeof(Float_t), 1, datei ) ;
    343   fwrite ( &fFwhmFadc  , sizeof(Float_t), 1, datei ) ;
    344 
    345   fwrite ( &fTrig      , sizeof(Float_t), TRIGBINS, datei ) ;
     337  fwrite ( &version,               sizeof(Float_t), 1, datei );
     338  fwrite ( &fBrightness,           sizeof(Float_t), 1, datei );
     339  fwrite ( &fTimeRange,            sizeof(Float_t), 1, datei );
     340  fwrite ( &fFadcSlicesPerNanosec, sizeof(Float_t), 1, datei );
     341
     342  fwrite ( &fBinsTrig  , sizeof(Int_t),   1, datei );
     343  fwrite ( &fTrigShape , sizeof(Int_t),   1, datei );
     344  fwrite ( &fAmplTrig  , sizeof(Float_t), 1, datei );
     345  fwrite ( &fFwhmTrig  , sizeof(Float_t), 1, datei );
     346
     347  fwrite ( &fBinsFadc  , sizeof(Int_t),   1, datei );
     348  fwrite ( &fFadcShape , sizeof(Int_t),   1, datei );
     349  fwrite ( &fIntegFadc , sizeof(Float_t), 1, datei );
     350  fwrite ( &fFwhmFadc  , sizeof(Float_t), 1, datei );
     351
     352  fwrite (fTrig, sizeof(Float_t), fBinsTrig, datei);
    346353
    347354  //    We want to store the FADC signal taking into account the AC
    … …  
    351358  //
    352359
    353   Float_t baseline = 0. ;
    354 
    355   for (Int_t i=0; i< FADCBINS ; i++ ) {
    356    
    357     baseline = baseline + fFadc[i]  ;
    358   }
    359 
    360   baseline = baseline / FADCBINS ;
    361  
    362   for (Int_t i=0; i< FADCBINS ; i++ ) {
    363    
    364       fFadc[i]=fFadc[i]-baseline;
    365    
    366   }
    367  
    368   fwrite ( &fFadc      , sizeof(Float_t), FADCBINS, datei ) ;
    369 
    370 
    371   fclose ( datei ) ;
     360  Float_t baseline = 0.;
     361
     362  for (Int_t i=0; i< fBinsFadc ; i++ )
     363    baseline += fFadc[i];
     364
     365  baseline /= fBinsFadc;
     366
     367  Float_t *temp = new Float_t[fBinsFadc];
     368
     369  for (Int_t i=0; i < fBinsFadc; i++ )
     370    temp[i] = fFadc[i]-baseline;
     371 
     372  fwrite (temp, sizeof(Float_t), fBinsFadc, datei);
     373
     374  delete [] temp;
     375
     376  fclose ( datei );
    372377 
    373378}
    … …  
    393398
    394399  Float_t read_version;
    395   Float_t current_version=VERSIONSR;
    396 
    397   // Check taht we read the right version of the Database
     400  Float_t current_version = VERSIONSR;
     401
     402  // Check that we read the right version of the Database
    398403  fread ( &read_version, sizeof(Float_t), 1, datei ) ;
    399404
    400405  if(Int_t(read_version)!=Int_t(current_version)){
    401406    cout<<" ERROR: You are trying to read database VERSION "<<
    402       read_version<<endl;
     407      read_version << endl;
    403408    cout<<"        You must generate a database for the current VERSION "<<
    404       current_version<<endl;
     409      current_version << endl;
    405410    cout<<"        See the NSB database section in the Camera How to Use note."
    406411        <<endl;
    … …  
    408413  }
    409414
    410   fread ( &fBrightness, sizeof(Float_t), 1, datei ) ;
    411   fread ( &fTimeRange , sizeof(Float_t), 1, datei ) ;
    412 
    413 
    414   fread ( &fBinsTrig  , sizeof(Float_t), 1, datei ) ;
    415   fread ( &fTrigShape , sizeof(Float_t), 1, datei ) ;
    416   fread ( &fAmplTrig  , sizeof(Float_t), 1, datei ) ;
    417   fread ( &fFwhmTrig  , sizeof(Float_t), 1, datei ) ;
    418 
    419   fread ( &fBinsFadc  , sizeof(Float_t), 1, datei ) ;
    420   fread ( &fFadcShape , sizeof(Float_t), 1, datei ) ;
    421   fread ( &fIntegFadc , sizeof(Float_t), 1, datei ) ;
    422   fread ( &fFwhmFadc  , sizeof(Float_t), 1, datei ) ;
    423 
    424   fread ( &fTrig      , sizeof(Float_t), TRIGBINS, datei ) ;
    425 
    426   fread ( &fFadc      , sizeof(Float_t), FADCBINS, datei ) ;
    427 
    428  
     415  fread ( &fBrightness, sizeof(Float_t), 1, datei );
     416  fread ( &fTimeRange , sizeof(Float_t), 1, datei );
     417  fread ( &fFadcSlicesPerNanosec, sizeof(Float_t), 1, datei );
     418
     419  fread ( &fBinsTrig  , sizeof(Int_t),   1, datei );
     420  fread ( &fTrigShape , sizeof(Int_t),   1, datei );
     421  fread ( &fAmplTrig  , sizeof(Float_t), 1, datei );
     422  fread ( &fFwhmTrig  , sizeof(Float_t), 1, datei );
     423
     424  fread ( &fBinsFadc  , sizeof(Int_t),   1, datei );
     425  fread ( &fFadcShape , sizeof(Int_t),   1, datei );
     426  fread ( &fIntegFadc , sizeof(Float_t), 1, datei );
     427  fread ( &fFwhmFadc  , sizeof(Float_t), 1, datei );
     428
     429  if (fTrig)
     430    delete [] fTrig;
     431
     432  if (fFadc)
     433    delete [] fFadc;
     434
     435  fTrig = new Float_t[fBinsTrig];
     436  fFadc = new Float_t[fBinsFadc];
     437
     438  fread (fTrig, sizeof(Float_t), fBinsTrig, datei);
     439  fread (fFadc, sizeof(Float_t), fBinsFadc, datei);
    429440
    430441  fclose ( datei ) ;
    431442}
    432 
    433 
    434 
    435 
Note: See TracChangeset for help on using the changeset viewer.