Implementation of Trigger simulation (Raphael Tieulent)
authorcheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 Jun 2009 15:07:02 +0000 (15:07 +0000)
committercheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 Jun 2009 15:07:02 +0000 (15:07 +0000)
VZERO/AliVZERODataDCS.cxx
VZERO/AliVZERODigitizer.cxx
VZERO/AliVZEROPreprocessor.cxx
VZERO/AliVZEROPreprocessor.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROTrigger.cxx
VZERO/AliVZEROTrigger.h
VZERO/AliVZEROdigit.cxx
VZERO/AliVZEROdigit.h
VZERO/VZERObaseLinkDef.h
VZERO/libVZERObase.pkg

index 1aa2195..4e618c4 100644 (file)
@@ -96,7 +96,7 @@ void AliVZERODataDCS::ProcessData(TMap& aliasMap){
       return;
     }
 
-    Introduce(iAlias, aliasArr);
+    //Introduce(iAlias, aliasArr);
     
     if(aliasArr->GetEntries()<2){
       AliError(Form("Alias %s has just %d entries!",
@@ -116,6 +116,7 @@ void AliVZERODataDCS::ProcessData(TMap& aliasMap){
                Values[iValue] = aValue->GetFloat();
                Times[iValue] = (Double_t) (aValue->GetTimeStamp());
                fHv[iAlias]->Fill(Values[iValue]);
+               printf("%s %f\n",fAliasNames[iAlias].Data(),Values[iValue]);
                iValue++;
     }      
     CreateGraph(iAlias, aliasArr->GetEntries(), Times, Values); // fill graphs 
index d7b2d1a..6ccee07 100644 (file)
@@ -157,40 +157,48 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
   // on these rings... 
    
   for(Int_t i=0; i<16; i++) { 
-            adc_gain[i] = fCalibData->GetGain(i); 
-            cPM[i]      = fPhotoCathodeEfficiency * pmGain_smeared[i];}
+       adc_gain[i] = fCalibData->GetGain(i); 
+       cPM[i]      = fPhotoCathodeEfficiency * pmGain_smeared[i];
+  }
   
   for(Int_t j=16; j<48; j=j+2) { 
-            Int_t i=(j+17)/2;
-            adc_gain[j]   = fCalibData->GetGain(i);        
-           adc_gain[j+1] = fCalibData->GetGain(i); 
-           cPM[j]        = fPhotoCathodeEfficiency * pmGain_smeared[i];   
-           cPM[j+1]      = fPhotoCathodeEfficiency * pmGain_smeared[i]; }
+       Int_t i=(j+17)/2;
+       adc_gain[j]   = fCalibData->GetGain(i);     
+       adc_gain[j+1] = fCalibData->GetGain(i); 
+       cPM[j]        = fPhotoCathodeEfficiency * pmGain_smeared[i];   
+       cPM[j+1]      = fPhotoCathodeEfficiency * pmGain_smeared[i]; 
+  }
            
   for(Int_t i=48; i<80; i++){ 
-            adc_gain[i] = fCalibData->GetGain(i-16); 
-           cPM[i]      = fPhotoCathodeEfficiency * pmGain_smeared[i-16];};
+         adc_gain[i] = fCalibData->GetGain(i-16); 
+       cPM[i]      = fPhotoCathodeEfficiency * pmGain_smeared[i-16];
+  };
   
-  for(Int_t  i=0; i<64; i++){ adc_pedestal[i] = fCalibData->GetPedestal(i); 
-                              adc_sigma[i]    = fCalibData->GetSigma(i); }; 
+  for(Int_t  i=0; i<64; i++){ 
+         adc_pedestal[i] = fCalibData->GetPedestal(i);
+         adc_sigma[i]    = fCalibData->GetSigma(i); 
+  }; 
                                 
 //  for(Int_t i=0; i<64; i++) { printf(" i = %d pedestal = %f sigma = %f \n\n", 
 //                                       i, adc_pedestal[i], adc_sigma[i] );} 
             
-  AliRunLoader* outRunLoader = 
-    AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());    
+  AliRunLoader* outRunLoader =  AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());    
   if (!outRunLoader) {
     Error("Exec", "Can not get output Run Loader");
-    return;}
+    return;
+  }
     
   AliLoader* outLoader = outRunLoader->GetLoader("VZEROLoader");
+
   if (!outLoader) {
     Error("Exec", "Can not get output VZERO Loader");
-    return;}
+    return;
+  }
 
   const char* mode = "update";
   if(outRunLoader->GetEventNumber() == 0) mode = "recreate";
   outLoader->LoadDigits(mode);
+
   if (!outLoader->TreeD()) outLoader->MakeTree("D");
   outLoader->MakeDigitsContainer();
   TTree* treeD  = outLoader->TreeD();
@@ -198,25 +206,27 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
   treeD->Branch("VZERODigit", &fDigits, bufsize); 
   
   for (Int_t iInput = 0; iInput < fManager->GetNinputs(); iInput++) {
-     AliRunLoader* runLoader = 
-     AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
+     AliRunLoader* runLoader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
      AliLoader* loader = runLoader->GetLoader("VZEROLoader");
      if (!loader) {
        Error("Exec", "Can not get VZERO Loader for input %d", iInput);
-       continue;}
+       continue;
+        }
       
      if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
 
      AliVZERO* vzero = (AliVZERO*) runLoader->GetAliRun()->GetDetector("VZERO");
      if (!vzero) {
        Error("Exec", "No VZERO detector for input %d", iInput);
-       continue;}
+       continue;
+        }
       
      loader->LoadHits();
      TTree* treeH = loader->TreeH();
      if (!treeH) {
        Error("Exec", "Cannot get TreeH for input %d", iInput);
-       continue; }
+       continue; 
+        }
        
      for(Int_t i=0; i<80; i++) {map[i] = 0; time[i] = 0.0;}
      
@@ -231,15 +241,16 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
          treeH->GetEvent(iTrack);
          Int_t nHits = hits->GetEntriesFast();
          for (Int_t iHit = 0; iHit < nHits; iHit++) {
-            AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
-            Int_t nPhot = hit->Nphot();
-            Int_t cell  = hit->Cell();                          
-            map[cell] += nPhot;
-            Float_t dt_scintillator = gRandom->Gaus(0,0.7);
-            Float_t t = dt_scintillator + 1e9*hit->Tof();
-            if (t > 0.0) {
-               if(t < time_ref[cell]) time_ref[cell] = t;
-               time[cell] = TMath::Min(t,time_ref[cell]); }
+                        AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
+                        Int_t nPhot = hit->Nphot();
+                        Int_t cell  = hit->Cell();                          
+                        map[cell] += nPhot;
+                        Float_t dt_scintillator = gRandom->Gaus(0,0.7);
+                        Float_t t = dt_scintillator + 1e9*hit->Tof();
+                        if (t > 0.0) {
+                                if(t < time_ref[cell]) time_ref[cell] = t;
+                                time[cell] = TMath::Min(t,time_ref[cell]); 
+                        }
          }           // hit   loop      
      }             // track loop
 
@@ -288,12 +299,13 @@ void AliVZERODigitizer::Exec(Option_t* /*option*/)
         
    for (Int_t i=0; i<64; i++) {      
       if(adc[i] > 0) {
-//           printf(" Event, cell, adc, tof = %d %d %d %f\n", 
-//                    outRunLoader->GetEventNumber(),i, map[i], time2[i]*10.0);
+//           printf(" Event, cell, adc, tof = %d %d %d %d\n", 
+//                    outRunLoader->GetEventNumber(),i, adc[i], Int_t((time2[i]*10.0) +0.5));
 //           multiply by 10 to have 100 ps per channel :
-             AddDigit(i, adc[i], Int_t((time2[i]*10.0) +0.5)) ;}      
+                 
+                 AddDigit(i, adc[i], Int_t((time2[i]*10.0) +0.5)) ;
+         }      
    }
-    
   treeD->Fill();
   outLoader->WriteDigits("OVERWRITE");  
   outLoader->UnloadDigits();     
@@ -307,7 +319,12 @@ void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time)
 // Adds Digit 
  
   TClonesArray &ldigits = *fDigits;  
-  new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time);
+  Bool_t integrator;
+  if (((Int_t) gRandom->Uniform(2))<1) integrator = kFALSE;
+  else integrator = kTRUE;
+        
+  new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time,0,kFALSE,kFALSE,integrator);
+        
 }
 //____________________________________________________________________________
 void AliVZERODigitizer::ResetDigit()
index ae4fdf3..3093c9b 100644 (file)
@@ -1,5 +1,6 @@
 #include "AliVZEROPreprocessor.h"
 #include "AliVZEROCalibData.h"
+#include "AliVZEROTriggerData.h"
 #include "AliCDBMetaData.h"
 #include "AliCDBEntry.h"
 #include "AliDCSValue.h"
@@ -18,8 +19,9 @@ ClassImp(AliVZEROPreprocessor)
 
 //______________________________________________________________________________________________
 AliVZEROPreprocessor::AliVZEROPreprocessor(AliShuttleInterface* shuttle) :
-  AliPreprocessor("V00", shuttle),
-  fData(0)
+       AliPreprocessor("V00", shuttle),
+       fData(0),
+       fFEEData(0)
  
 {
   // constructor  
@@ -33,15 +35,16 @@ AliVZEROPreprocessor::AliVZEROPreprocessor(AliShuttleInterface* shuttle) :
 AliVZEROPreprocessor::~AliVZEROPreprocessor()
 {
   // destructor
-  
-   delete fData;
+       delete fFEEData;
+       delete fData;
+       
 }
 
 //______________________________________________________________________________________________
 void AliVZEROPreprocessor::Initialize(Int_t run, UInt_t startTime,
        UInt_t endTime)
 {
-  // Creates AliZDCDataDCS object
+  // Creates AliVZERODataDCS object
 
    AliPreprocessor::Initialize(run, startTime, endTime);
   
@@ -55,7 +58,8 @@ void AliVZEROPreprocessor::Initialize(Int_t run, UInt_t startTime,
    fStartTime = GetStartTimeDCSQuery ();
    fEndTime   = GetEndTimeDCSQuery ();
 
-   fData      = new AliVZERODataDCS(fRun, fStartTime, fEndTime);
+       fData      = new AliVZERODataDCS(fRun, fStartTime, fEndTime);
+       fFEEData   = new AliVZERODataFEE(fRun, fStartTime, fEndTime);           
    
 }
 
@@ -75,11 +79,11 @@ UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
   TString fileName; 
   AliVZEROCalibData *calibData = new AliVZEROCalibData();
   
-  // *************** From DCS ******************
+  // *************** HV From DCS ******************
   // Fills data into a AliVZERODataDCS object
   if(!dcsAliasMap) return 1;
 
-       // The processing of the DCS input data is forwarded to AliVZERODataDCS
+       // The Processing of the DCS input data is forwarded to AliVZERODataDCS
 
        fData->ProcessData(*dcsAliasMap);
        //fData->Draw("");              // Draws the HV values as a function of time
@@ -153,6 +157,30 @@ UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
   delete calibData;
   delete sourceList; 
 
+ // -----------------------------------------------------------------------
+ // Retrieve Front End Electronics Parameters from the DCS
+ // -----------------------------------------------------------------------
+       AliVZEROTriggerData *triggerData = new AliVZEROTriggerData();
+
+       // The processing of the DCS input data is forwarded to AliVZERODataFEE
+       fFEEData->ProcessData(*dcsAliasMap);
+
+       // Writes VZERO FEE parameters values into VZERO  Trigger parametrization object
+       triggerData->FillData(fFEEData);
+
+       // Stores the VZERO Trigger Object into CalibrationDB
+       
+       resECal=kTRUE;
+       
+       result = 0;
+       metaData.SetBeamPeriod(0);
+       metaData.SetResponsible("Brigitte Cheynis");
+       metaData.SetComment("This preprocessor fills an AliVZEROTriggerData object");
+       
+       resECal = Store("Trigger", "Data", triggerData, &metaData, 0, kTRUE);
+       if(resECal==kFALSE ) result = 1;
+       
+       
   return result;
 }
 
index 9e94a01..8ec1037 100644 (file)
@@ -3,6 +3,7 @@
 
 #include "AliPreprocessor.h"
 #include "AliVZERODataDCS.h"
+#include "AliVZERODataFEE.h"
 #include "AliShuttleInterface.h"
 
 // VZERO PreProcessor  header 
@@ -18,13 +19,15 @@ class AliVZEROPreprocessor : public AliPreprocessor
   protected:
     virtual UInt_t Process(TMap* dcsAliasMap);
 
-    AliVZERODataDCS *fData;    // CDB class that stores the data
+    AliVZERODataDCS *fData;    // CDB class that stores the data for HV
+       AliVZERODataFEE *fFEEData; // CDB class that stores the data for FEE
+
 
  private:
     AliVZEROPreprocessor(const AliVZEROPreprocessor&); // Not implemented
     AliVZEROPreprocessor& operator=(const AliVZEROPreprocessor&); // Not implemented
     
-    ClassDef(AliVZEROPreprocessor, 0);
+    ClassDef(AliVZEROPreprocessor, 1);
 };
 
 #endif
index ce19540..2b4b005 100644 (file)
@@ -33,6 +33,7 @@
 #include "AliVZEROTriggerMask.h"
 #include "AliESDfriend.h"
 #include "AliESDVZEROfriend.h"
+#include "AliVZEROdigit.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -101,7 +102,7 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   rawReader->Reset();
   AliVZERORawStream rawStream(rawReader);
   if (rawStream.Next()) {  
-     Int_t ADC_max[64], adc[64], time[64], width[64], BBFlag[64], BGFlag[64];   
+     Int_t ADC_max[64], adc[64], time[64], width[64], BBFlag[64], BGFlag[64], integrator[64];   
      for(Int_t i=0; i<64; i++) {
          // Search for the maximum charge in the train of 21 LHC clocks 
          // regardless of the integrator which has been operated:
@@ -119,6 +120,7 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
         width[j]  =  rawStream.GetWidth(i);
         BBFlag[j] =  rawStream.GetBBFlag(i,imax);
         BGFlag[j] =  rawStream.GetBGFlag(i,imax); 
+        integrator[j] =  rawStream.GetIntegratorFlag(i,imax); 
 
         // Filling the esd friend object
         fESDVZEROfriend->SetBBScalers(j,rawStream.GetBBScalers(i));
@@ -154,7 +156,7 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
      for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
          new ((*digitsArray)[digitsArray->GetEntriesFast()])
              AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
-                          width[iChannel], BBFlag[iChannel], BGFlag[iChannel]);
+                          width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]);
      }
   }
 
@@ -211,6 +213,7 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
        BBFlag[pmNumber]= digit->BBFlag();
        BGFlag[pmNumber]= digit->BGFlag();
         // printf("PM = %d,  MIP per ADC channel = %f \n",pmNumber, fCalibData->GetMIPperADC(pmNumber));
+               //AliInfo(Form("PM = %d,  ADC = %d TDC %d",pmNumber, digit->ADC(),digit->Time()));
         // cut of ADC at 1MIP/2 
        if(fCollisionMode >0) { 
           Float_t MIP = 2.0;  
index a84380c..ced1cd8 100644 (file)
 
 #include "AliRun.h"
 #include "AliRunLoader.h"
+#include "AliTriggerInput.h"
 
+#include "AliVZEROdigit.h"
+#include "AliVZEROTriggerSimulator.h"
 #include "AliVZEROTrigger.h"
-#include "AliVZEROTriggerMask.h"
 
 //______________________________________________________________________
 ClassImp(AliVZEROTrigger)
@@ -35,69 +37,79 @@ ClassImp(AliVZEROTrigger)
 
 //______________________________________________________________________
 
-AliVZEROTrigger::AliVZEROTrigger()
-  :AliTriggerDetector(),
-   fAdcThresHold(0.0),
-   fTimeWindowWidthBBA(50.0),
-   fTimeWindowWidthBGA(20.0),
-   fTimeWindowWidthBBC(50.0),
-   fTimeWindowWidthBGC(20.0)
-   
+AliVZEROTrigger::AliVZEROTrigger():AliTriggerDetector()
 {
    SetName("VZERO");
    CreateInputs();
-
-   SetAdcThreshold();
 }
 //______________________________________________________________________
 void AliVZEROTrigger::CreateInputs()
 {
-   // inputs
-
-   // Do not create inputs again!!
-   if( fInputs.GetEntriesFast() > 0 ) return;
-
-   fInputs.AddLast( new AliTriggerInput( "VZERO_LEFT", "VZERO", 0 ) );
-   fInputs.AddLast( new AliTriggerInput( "VZERO_RIGHT","VZERO", 0 ) );
-   fInputs.AddLast( new AliTriggerInput( "VZERO_AND",  "VZERO", 0 ) );
-   fInputs.AddLast( new AliTriggerInput( "VZERO_OR",   "VZERO", 0 ) );
-   fInputs.AddLast( new AliTriggerInput( "VZERO_BEAMGAS", "VZERO", 0 ) );
+       // Do not create inputs again!!
+       if( fInputs.GetEntriesFast() > 0 ) return;
+
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BBA_AND_BBC", "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BBA_OR_BBC","VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BGA_AND_BBC",  "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BGA",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BGC_AND_BBA", "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BGC",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_CTA1_AND_CTC1",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_CTA1_OR_CTC1",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_CTA2_AND_CTC2",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_CTA2_OR_CTC2",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_MTA_AND_MTC",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_MTA_OR_MTC",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BBA",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BBC",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BGA_OR_BGC",   "VZERO", 0 ) );
+       fInputs.AddLast( new AliTriggerInput( "VZERO_BEAMGAS",   "VZERO", 0 ) );
+       
 }
 
 //______________________________________________________________________
 void AliVZEROTrigger::Trigger()
 {
-  
   //  ********** Get run loader for the current event **********
-  AliRunLoader* runLoader = AliRunLoader::Instance();
-
-  AliVZEROLoader* loader = 
-    (AliVZEROLoader* )runLoader->GetLoader( "VZEROLoader" );
-
-  loader->LoadDigits("READ");
-  TTree* vzeroDigitsTree = loader->TreeD();
-  if (!vzeroDigitsTree) return;
-
-  TClonesArray* vzeroDigits = new TClonesArray("AliVZEROdigit",1000);
-  TBranch* digitBranch = vzeroDigitsTree->GetBranch("VZERODigit");
-  digitBranch->SetAddress(&vzeroDigits);
-
-  AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask();
-  TriggerMask->SetAdcThreshold(fAdcThresHold);
-  TriggerMask->SetTimeWindowWidthBBA(fTimeWindowWidthBBA);
-  TriggerMask->SetTimeWindowWidthBGA(fTimeWindowWidthBGA);
-  TriggerMask->SetTimeWindowWidthBBC(fTimeWindowWidthBBC);
-  TriggerMask->SetTimeWindowWidthBGC(fTimeWindowWidthBGC);
-  TriggerMask->FillMasks(vzeroDigitsTree,vzeroDigits);
-
-  if ( (TriggerMask->GetBGtriggerV0A()>0) ||
-       (TriggerMask->GetBGtriggerV0C()>0)) SetInput( "VZERO_BEAMGAS" );
-  if (TriggerMask->GetBBtriggerV0A()>0)  SetInput( "VZERO_LEFT" );
-  if (TriggerMask->GetBBtriggerV0C()>0)  SetInput( "VZERO_RIGHT" );
-  if ( (TriggerMask->GetBBtriggerV0A()>0) ||
-       (TriggerMask->GetBBtriggerV0C()>0)) SetInput( "VZERO_OR" );
-  if ( (TriggerMask->GetBBtriggerV0A()>0) &&
-       (TriggerMask->GetBBtriggerV0C()>0)) SetInput( "VZERO_AND" );
+       AliRunLoader* runLoader = AliRunLoader::Instance();
+
+       AliLoader* loader = runLoader->GetLoader( "VZEROLoader" );
+
+       if(!loader) {
+               AliError("Can not get VZERO loader");
+               return;
+       }
+       loader->LoadDigits("READ");
+       TTree* vzeroDigitsTree = loader->TreeD();
+
+       if (!vzeroDigitsTree) {
+               AliError("Can not get the VZERO digit tree");
+               return;
+       }
+       TClonesArray* vzeroDigits = NULL;
+       TBranch* digitBranch = vzeroDigitsTree->GetBranch("VZERODigit");
+       digitBranch->SetAddress(&vzeroDigits);
+
+       AliVZEROTriggerSimulator * triggerSimulator = new AliVZEROTriggerSimulator(vzeroDigitsTree,vzeroDigits);
+       
+       triggerSimulator->Run();
+       
+       if(triggerSimulator->GetBBAandBBC())    SetInput( "VZERO_BBA_AND_BBC" );
+       if(triggerSimulator->GetBBAorBBC())             SetInput( "VZERO_BBA_OR_BBC" );
+       if(triggerSimulator->GetBGAandBBC())    SetInput( "VZERO_BGA_AND_BBC" );
+       if(triggerSimulator->GetBGA())                  SetInput( "VZERO_BGA" );
+       if(triggerSimulator->GetBGCandBBA())    SetInput( "VZERO_BGC_AND_BBA" );
+       if(triggerSimulator->GetBGC())                  SetInput( "VZERO_BGC" );
+       if(triggerSimulator->GetCTA1andCTC1())  SetInput( "VZERO_CTA1_AND_CTC1" );
+       if(triggerSimulator->GetCTA1orCTC1())   SetInput( "VZERO_CTA1_OR_CTC1" );
+       if(triggerSimulator->GetCTA2andCTC2())  SetInput( "VZERO_CTA2_AND_CTC2" );
+       if(triggerSimulator->GetCTA1orCTC1())   SetInput( "VZERO_CTA1_OR_CTC1" );
+       if(triggerSimulator->GetMTAandMTC())    SetInput( "VZERO_MTA_AND_MTC" );
+       if(triggerSimulator->GetMTAorMTC())             SetInput( "VZERO_MTA_OR_MTC" );
+       if(triggerSimulator->GetBBA())                  SetInput( "VZERO_BBA" );
+       if(triggerSimulator->GetBBC())                  SetInput( "VZERO_BBC" );
+       if(triggerSimulator->GetBGAorBGC())             SetInput( "VZERO_BGA_OR_BGC" );
+       if(triggerSimulator->GetBeamGas())              SetInput( "VZERO_BEAMGAS" );
 
   return;
 }
index f3e4bd4..dfe6d16 100644 (file)
@@ -8,13 +8,6 @@
 
 
 #include "AliTriggerDetector.h"
-#include "AliTriggerInput.h"
-
-#include "AliVZEROLoader.h"
-#include "AliVZEROdigit.h"
-
-#include "AliLog.h"
-
 
 class AliVZEROTrigger : public AliTriggerDetector
 {
@@ -24,31 +17,7 @@ class AliVZEROTrigger : public AliTriggerDetector
    virtual void    CreateInputs();
    virtual void    Trigger();
 
-   void            SetAdcThreshold(Float_t t=55.0) 
-     {fAdcThresHold=t; 
-     AliDebug(1,Form("ADC threshold set to %0.2f", fAdcThresHold));}
-   
-   void            SetTimeWindowWidth(Float_t w=50.0) 
-     {fTimeWindowWidthBBA=fTimeWindowWidthBGA
-       =fTimeWindowWidthBBC=fTimeWindowWidthBGC=w;}
-   void            SetTimeWindowWidthBBA(Float_t w=50.0)
-     {fTimeWindowWidthBBA=w;}
-   void            SetTimeWindowWidthBBC(Float_t w=50.0)
-     {fTimeWindowWidthBBC=w;}
-   void            SetTimeWindowWidthBGA(Float_t w=20.0) 
-     {fTimeWindowWidthBGA=w;}
-   void            SetTimeWindowWidthBGC(Float_t w=20.0) 
-     {fTimeWindowWidthBGC=w;}
-
-private:
-
-   Float_t fAdcThresHold;
-   Float_t fTimeWindowWidthBBA; // 
-   Float_t fTimeWindowWidthBGA; // 
-   Float_t fTimeWindowWidthBBC; // 
-   Float_t fTimeWindowWidthBGC; // 
-
-   ClassDef( AliVZEROTrigger, 1 )  // VZERO Trigger Detector class
+   ClassDef( AliVZEROTrigger, 2 )  // VZERO Trigger Detector class
 };
 
 #endif // AliVZEROTrigger_H
index b8395bb..6b0da7e 100644 (file)
@@ -27,7 +27,8 @@ AliVZEROdigit::AliVZEROdigit()
     fTime(0),
     fWidth(0),
     fBBFlag(0),
-    fBGFlag(0)
+    fBGFlag(0),
+       fIntegrator(0)
 
 {
   // Standard default constructor 
@@ -43,7 +44,8 @@ AliVZEROdigit::AliVZEROdigit(Int_t* tracks, Int_t *digits)
    fTime(0),
    fWidth(0),
    fBBFlag(0),
-   fBGFlag(0)
+   fBGFlag(0),
+   fIntegrator(0)
   
 {
   // Creates VZERO digits  
@@ -63,7 +65,8 @@ AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time)
    fTime(0),
    fWidth(0),
    fBBFlag(0),
-   fBGFlag(0)
+   fBGFlag(0),
+       fIntegrator(0)
 {  
    fPMNumber   = PMnumber;
    fADC        = adc;
@@ -76,21 +79,31 @@ AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time,
    :AliDigit(),
    fTrack(0),
    fEvent(0),
-   fPMNumber(0),
-   fADC(0),
-   fTime(0),
-   fWidth(0),
-   fBBFlag(0),
-   fBGFlag(0)
+   fPMNumber(PMnumber),
+   fADC(adc),
+   fTime(time),
+   fWidth(width),
+   fBBFlag(BeamBeamFlag),
+       fBGFlag(BeamGasFlag),
+       fIntegrator(0)
 {  
 
-   fPMNumber   = PMnumber;    // PM number
-   fADC        = adc;         // ADC value
-   fTime       = time;        // Leading time 
-   fWidth      = width;       // Time Width
-   fBBFlag     = BeamBeamFlag;      // Beam Beam Flag
-   fBGFlag     = BeamGasFlag;      // Beam Gas  Flag
-
+}
+//__________________________________________________________________________
+AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Int_t adc, Int_t time, 
+                             Int_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag, Bool_t integrator)
+:AliDigit(),
+fTrack(0),
+fEvent(0),
+fPMNumber(PMnumber),
+fADC(adc),
+fTime(time),
+fWidth(width),
+fBBFlag(BeamBeamFlag),
+fBGFlag(BeamGasFlag),
+fIntegrator(integrator)
+{  
+       
 }
 
 //__________________________________________________________________________
index ac87b4b..62b60ff 100644 (file)
@@ -16,6 +16,8 @@ class AliVZEROdigit: public AliDigit  {
     AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */);
     AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */, 
                   Int_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */);
+    AliVZEROdigit(Int_t /* PMnumber */, Int_t  /* ADC */, Int_t /* Time */, 
+                  Int_t /* TimeWidth*/, Bool_t /* BBFlag */, Bool_t /* BGFlag */, Bool_t /* Integrator */);
     virtual ~AliVZEROdigit() {};
     virtual void Print(const Option_t* option="") const;
     
@@ -25,6 +27,7 @@ class AliVZEROdigit: public AliDigit  {
     Int_t   Width()    const {return fWidth;} 
     Bool_t  BBFlag()   const {return fBBFlag;} 
     Bool_t  BGFlag()   const {return fBGFlag;}
+    Bool_t  Integrator()   const {return fIntegrator;}
        
   private:
     Int_t  fTrack;         // Track number
@@ -37,8 +40,9 @@ class AliVZEROdigit: public AliDigit  {
     Int_t  fWidth;         // Width of the time distribution
     Bool_t fBBFlag;        // Beam-Beam Flag given by Yannick in Raw Data only
     Bool_t fBGFlag;        // Beam-Gas  Flag given by Yannick in Raw Data only
+       Bool_t fIntegrator;        // Integrator used
     
-    ClassDef(AliVZEROdigit,2)  //Digit (Header) object for set : VZERO
+    ClassDef(AliVZEROdigit,3)  //Digit (Header) object for set : VZERO
 };
 
 #endif
index 89bb770..e2c00cf 100755 (executable)
@@ -13,5 +13,9 @@
 #pragma link C++ class  AliVZERODataDCS+;
 #pragma link C++ class  AliVZEROQAChecker+;
 #pragma link C++ class  AliVZEROMisAligner+;
+#pragma link C++ class  AliVZEROLogicalSignal+;
+#pragma link C++ class  AliVZERODataFEE+;
+#pragma link C++ class  AliVZEROTriggerSimulator+;
+#pragma link C++ class  AliVZEROTriggerData+;
 
 #endif
index 43d500b..43d5f42 100644 (file)
@@ -7,8 +7,11 @@ SRCS= AliVZEROLoader.cxx \
       AliVZEROPreprocessor.cxx \
       AliVZERODataDCS.cxx \
       AliVZEROQAChecker.cxx \
-      AliVZEROMisAligner.cxx
-
+      AliVZEROMisAligner.cxx \
+         AliVZEROLogicalSignal.cxx \
+         AliVZERODataFEE.cxx \
+         AliVZEROTriggerSimulator.cxx \
+         AliVZEROTriggerData.cxx 
 HDRS:= $(SRCS:.cxx=.h)
 
 DHDR:=VZERObaseLinkDef.h