Most of these updates are related to the offline software needed for the pixel trigge...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Apr 2009 20:02:49 +0000 (20:02 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Apr 2009 20:02:49 +0000 (20:02 +0000)
commitad7f2bfa13b73e2fb13f097a478710c3bc1d47a3
tree9acc7f92b5b40bb35bf407bd8481d04c2d6689cc
parent0ea3c44eabb3f62413489acb02822fbdc47b7028
Most of these updates are related to the offline software needed for the pixel trigger, for instance:
* Managing pixel trigger conditions data.
* Simulating generation of fast-or signals from SPD.
* Simulating pixel trigger response.
See also class schematics at http://tydes.home.cern.ch/tydes/doc/PitOffline

The treatment of dead/noisy pixels has also changed, both in the simulation and the reconstruction step. During simulation, it will be possible (via AliITSSimuParam) to choose whether dead/noisy pixels should be removed/added. Default is to add noisy pixels (which may be none, as one likes), but not to remove dead pixels. A similar choice for local reconstruction (via AliITSRecoParam) removes by default both noisy and dead pixels before the clusterization step. This is the safe way to proceed. However, in case of real data, one might speed up by skipping the removal of dead pixels, since they could not appear - by definition - in this case. With this strategy there will hopefully be less confusion on the meaning of dead and noisy pixels.

--------------------
MODIFIED/NEW CLASSES
--------------------

AliITS:
* CreateTriggerDetector is passing the AliITSTriggerConditions to AliITSTrigger upon creation.
* In HitsToDigits and SDigitsToDigits, AliITSDetTypeSim object (which takes care of generating the AliITSFOSignalsSPD) will be called to reset the fast-or signals before the event and to add noise and store them after wards (using the AliITSLoader).
* Digits2Raw will take the AliITSFOSignalsSPD from the AliITSLoader in order to pass them to AliITSDDLRawData::RawDataSPD, where they will be added to the simulated raw data.

AliITSClusterFinderV2SPD:
* The two FindClustersSPD methods (one for raw data, one for digits) are now filling the FastOrFiredMap (TBits) member of AliITSDetTypeRec. Fast-or signals come either directly from raw data or from AliITSFOSignalsSPD object in digits file.
* Before clustering, there is a possibility to remove noisy and dead pixels from the fired pixel map. Default is to remove both noisy and dead, but may be changed via AliITSRecoParam. In case of real data one might want to speed up by skipping removing dead pixels (which anyway should not appear in this case).
* Henrik's comment: The name of this class is a bit misleading, since it does several things apart from clustering. It might be discussed if one should separate into something like AliITSLocalReconstructionSPD and AliITSClusterFinderSPD. For instance, with the existing code, it is a bit strange that the cluster finder needs to know how the raw data is written, what a digit is, and so on.

AliITSDDLRawData:
* Modified to be able to write fast-or signals into raw data. The signals are fed from outside to this class (see AliITS::Digits2Raw).
* The procedure that converts digits into raw data (inside GetDigitsSPD method) was reimplemented, since the old code was unreadable.

AliITSDetTypeRec:
* Added pointer to AliITSFOSignalsSPD. This is used to let the AliITSClusterFinderV2SPD access the fast-or signals generated during simulation.
* Added pointer to AliITSTriggerConditions. This is used to remove the inactive chips from the fFastOrFiredMap (TBits), needed in real data. This is done in method RemoveFastOrFiredInActive. The fFastorFiredMap will eventually go into the AliMultiplicity class in the ESD.

AliITSDetTypeSim:
* Added AliITSFOGeneratorSPD object to take care of simulating the generation of fast-or signals.
* Added pointer to noisy calibration objects read from OCDB.
* Added pointer to AliITSTriggerConditions, needed by the AliITSFOGeneratorSPD object.
* GetCalibration method reads AliITSFOEfficiencySPD and AliITSFONoiseSPD objects from OCDB and passes them to the AliITSFOGeneratorSPD object.
* Takes care of storing the generated fast-or signals via AliITSLoader.

AliITSLoader:
* Added an AliBaseLoader for the AliITSFOSignalsSPD object that should be stored in the 'ITS.Digits.root' file. It is placed as a second loader (AliObjectLoader in this case) in the digits data loader, next to the digits tree loader (AliTreeLoader). Its name is the same as the class - 'AliITSFOSignalsSPD'.
* The Load/UnloadDigits methods are presently not taking care of this new loader. It is not clear which is the best way to solve this. It may require changes to the AliLoader class itself.

AliITSRawStreamSPD:
* Added method GetDDLID, which may be useful in places where there is no access to the AliRawReader object (just calls the AliRawReader::GetDDLID).
* Minor modifications to parsing of extra calibration headers.

AliITSsimulationSPD:
* Method RemoveDeadPixels slightly modified. Does not require the AliITSmodule as input anymore.
* Method AddNoisyPixels added. This will allow the possibility to explicitly add noisy pixels as digits, which could then also give rise to fast-or signals. For each noisy pixel, a noise 10 times the threshold will be added to the map.
* For each digit found in method FrompListToDigits (basically SDigits to Digits), the AliITSDetTypeSim::ProcessSPDDigitForFastOr will be called.

AliITSTrigger:
* Added object AliITSTriggerFOProcessor as member. This will take care of simulating the response of the pixel trigger system upon receiving a set of fast-or signals. It will need an AliITSTriggerConditions object, which normally is read from OCDB.
* The CreateInputs method will create inputs based on the AliITSTriggerConditions object.
* The Trigger method reads the AliITSFOSignalsSPD via AliITSLoader and asks the AliITSTriggerFOProcessor for a decision (yes/no) from each of the defined output lines. If yes, SetInput will be called.

ITSSPDSCANda:
* Modified initial comments, since this DA should not be used for run type DAQ_FO_UNIF_SCAN, as originally planned.
* Removed the temporary patch of reading chip present information, which is no longer needed.
* Mean threshold scan header format changed. The current DAC value will now be replaced by RowSpan and current DAC value should be taken from TPLow, assuming it is the same for all 6 half-staves of a half-sector.

AliITSFOEfficiencySPD:
* New class used to store information about the fast-or efficiency. The values stored are the probability that a pixel hit will generate a fast-or signal. In this base class there is one value for each pixel chip. The daughter class AliITSFOEfficiencySPDColumn may be used if there should be even a difference per pixel chip column.
* Will be put in OCDB as "ITS/Calib/SPDFOEfficiency". A new file with 100% efficiency for all is put as default.

AliITSFOEfficiencySPDColumn:
* New class that inherits from AliITSFOEfficiencySPD. May be used instead of base class, when the effiency values differ between single pixel chip columns.

AliITSFONoiseSPD:
* New class used to store information about the fast-or noise. The values stored are the probability that a pixel chip will generate a fast-or signal originating from random noise.
* Will be put in OCDB as "ITS/Calib/SPDFONoise". A new file with 0% noise for all is put as default.

AliITSFOGeneratorSPD:
* New class taking care of generation of fast-or signals in simulation.
* The ProcessPixelHit method should be called for each fired pixel found in the digitization procedure. The decision if the pixel will generate a fast-or signal will be based on an AliITSFOEfficiencySPD object which gives the probability.
* After digitization, method ProcessNoise should be called, which will add noise according to probabilities taken from an AliITSFONoiseSPD object.
* The final result is a filled AliITSFOSignalsSPD object, a member of this class.

AliITSFOSignalsSPD:
* New class that is able to store 1200 bits per event, each saying wether a pixel chip gave a fast-or signal or not. This object will be stored in the 'ITS.Digits.root' file during simulation.

AliITSTriggerConditions:
* New class that represents the conditions of the pixel trigger system. This object will contain the same information as is being sent by the pixel trigger system at start-of-run to DCS file exchange server, and taken offline by the shuttle. Preprocessor code will store the object in OCDB as "ITS/Calib/PITConditions". A new file with some default conditions is placed there.
* Data members: run number, firmware version, input config version, parameters version, a list of AliITSTriggerAlgorithmConditions objects, a list of inactive chips.

AliITSTriggerAlgorithmConditions:
* New class that holds the information regarding a single pixel trigger algorithm.
* Data members: label, id, description, number of parameters, parameter values, parameter names.

AliITSTriggerFOProcessor:
* New class that is able to process the AliITSFOSignalsSPD in order to evaluate if a given pixel trigger output is activated.
* Uses an AliITSTriggerConditions object to know the parameters corresponding to the algorithms in use.
* New algorithms should be added here as soon as they are implemented online. Only a couple of the existing online algorithms have been implemented here so far.
* The two algorithms used in the old AliITSTrigger code, have been adapted to the new framework and are added to the AliITSTriggerConditions object in ITS/Calib/PITConditions.

AliITSSimuParam:
* Added flag saying whether noisy pixels should be added at the level of digitization (which could then also lead to additional fast-or signals).
* Added flag saying whether dead pixels should be removed at the level of digitization.

AliITSRecoParam:
* Added flag saying whether noisy pixels should be removed at the level of local reconstruction (default is true).
* Added flag saying whether dead pixels should be removed at the level of local reconstruction (default is true, but may for instance be put to false to speed up in case of real data, since we then know the dead pixels would not appear in any case).

---------------
REMOVED CLASSES
---------------

AliITSFastOrCalibrationSPD:
* This class is removed, since it is no longer needed. The TBits of fast-or configured chips will be part of AliITSTriggerConditions from now on (instead represented as inactive chips). The calibration file, which before was in "ITS/Calib/SPDFastOr" is removed as well.

Henrik Tydesjo
43 files changed:
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSClusterFinderV2SPD.cxx
ITS/AliITSDDLRawData.cxx
ITS/AliITSDDLRawData.h
ITS/AliITSDetTypeRec.cxx
ITS/AliITSDetTypeRec.h
ITS/AliITSDetTypeSim.cxx
ITS/AliITSDetTypeSim.h
ITS/AliITSFOEfficiencySPD.cxx [new file with mode: 0644]
ITS/AliITSFOEfficiencySPD.h [new file with mode: 0644]
ITS/AliITSFOEfficiencySPDColumn.cxx [new file with mode: 0644]
ITS/AliITSFOEfficiencySPDColumn.h [new file with mode: 0644]
ITS/AliITSFOGeneratorSPD.cxx [new file with mode: 0644]
ITS/AliITSFOGeneratorSPD.h [new file with mode: 0644]
ITS/AliITSFONoiseSPD.cxx [new file with mode: 0644]
ITS/AliITSFONoiseSPD.h [new file with mode: 0644]
ITS/AliITSFOSignalsSPD.cxx [new file with mode: 0644]
ITS/AliITSFOSignalsSPD.h [new file with mode: 0644]
ITS/AliITSFastOrCalibrationSPD.cxx [deleted file]
ITS/AliITSFastOrCalibrationSPD.h [deleted file]
ITS/AliITSLoader.cxx
ITS/AliITSLoader.h
ITS/AliITSRawStreamSPD.h
ITS/AliITSRecoParam.cxx
ITS/AliITSRecoParam.h
ITS/AliITSSimuParam.h
ITS/AliITSTrigger.cxx
ITS/AliITSTrigger.h
ITS/AliITSTriggerAlgorithmConditions.cxx [new file with mode: 0644]
ITS/AliITSTriggerAlgorithmConditions.h [new file with mode: 0644]
ITS/AliITSTriggerConditions.cxx [new file with mode: 0644]
ITS/AliITSTriggerConditions.h [new file with mode: 0644]
ITS/AliITSTriggerFOProcessor.cxx [new file with mode: 0644]
ITS/AliITSTriggerFOProcessor.h [new file with mode: 0644]
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSPD.h
ITS/CMake_libITSbase.txt
ITS/CMake_libITSsim.txt
ITS/ITSbaseLinkDef.h
ITS/ITSsimLinkDef.h
ITS/libITSbase.pkg
ITS/libITSsim.pkg