emcOMGeometryT.h

Go to the documentation of this file.

#ifndef __EMCOMGEOMETRYT_H__
#define __EMCOMGEOMETRYT_H__

#ifndef __EMCMANAGEABLE_H__
#include "emcManageable.h"
#endif
#ifndef __EMCOBJECTMANAGER_H__
#include "emcObjectManager.h"
#endif

#include <string>
#include <iostream>

class emcGeometry;

template <class BM>
class emcOMGeometryT : public emcObjectManager
{

public:

  emcOMGeometryT(const char* name = "", const char* title = "");
  virtual ~emcOMGeometryT();

  virtual bool CanCollect(const emcManageable& object) const;

  virtual bool CanWrite(const emcManageable& object) const;

  virtual bool CanRead(const emcManageable& object) const;

  virtual emcManageable* Collect(const emcManageable& object,
                                 const PHTimeStamp& when);


  using emcObjectManager::Read;

  virtual bool Read(emcManageable& object,
                    const PHTimeStamp& time_stamp,
                    int id);

  virtual void Reset(void);

  virtual bool Write(const emcManageable& object,
                     const PHTimeStamp& tStart,
                     int id = -1);

private:
  emcGeometry* fGeometry;
  BM* fBM;

private:
  class changeName
  {
  public:
    changeName(const char* name)
    {
      name_ = emcManageable::GetStorageName(BM::storage());
      name_ += ":";
      name_ += name;
    }

    const char* c_str() const
    {
      return name_.c_str();
    }

  private:
    std::string name_;
  };
};

//_____________________________________________________________________________
//_____________________________________________________________________________
//_____________________________________________________________________________

#include <iostream>
#include <vector>

#ifndef __EMCDATAMANAGER_H__
#include "emcDataManager.h"
#endif
#ifndef __EMCGEOMETRY_H__
#include "emcGeometry.h"
#endif
#include "PdbCalBank.hh"
#include "PdbBankList.hh"
#include "PdbBankListIterator.hh"
#include "PdbEmcSecGeom.hh"
#include "Pdb.hh"
#include "PdbApplication.hh"
#include "PdbBankManager.hh"

//_____________________________________________________________________________
template <class BM>
emcOMGeometryT<BM>::emcOMGeometryT(const char* name, const char* title) :
  emcObjectManager(changeName(name).c_str(), title),
  fGeometry(0),
  fBM(new BM)
{
}

//_____________________________________________________________________________
template <class BM>
emcOMGeometryT<BM>::~emcOMGeometryT()
{
  Reset();
}


//_____________________________________________________________________________
template <class BM>
bool
emcOMGeometryT<BM>::CanCollect(const emcManageable& object) const
{
  return CanRead(object);
}


//_____________________________________________________________________________
template <class BM>
bool
emcOMGeometryT<BM>::CanWrite(const emcManageable& object) const
{
  if (object.GetDestination() != fBM->storage())
    {
      return false;
    }

  const emcManageable* object_ptr = &object;

  const emcGeometry* test =
    dynamic_cast<const emcGeometry*>(object_ptr);

  if ( test )
    {
      return true;
    }

  return false;
}

//_____________________________________________________________________________
template <class BM>
bool
emcOMGeometryT<BM>::CanRead(const emcManageable& object) const
{
  if ( object.GetSource() != fBM->storage() )
    {
      return false;
    }

  const emcManageable* object_ptr = &object;

  const emcGeometry* test =
    dynamic_cast<const emcGeometry*>(object_ptr);

  if ( test )
    {
      return true;
    }

  return false;
}

//_____________________________________________________________________________
template <class BM>
emcManageable*
emcOMGeometryT<BM>::Collect(const emcManageable&,
                            const PHTimeStamp& when)
{
  if ( fGeometry )
    {
      if (fGeometry->IsValid(when))
        {
          return fGeometry;
        }
    }

  if ( !fGeometry )
    {
      fGeometry = new emcGeometry();
    }

  bool ok = Read(*fGeometry, when, 1);

  if (!ok)
    {
      delete fGeometry;
      fGeometry = 0;
    }

  return fGeometry;

}

//_____________________________________________________________________________
template<class BM>
bool
emcOMGeometryT<BM>::Read(emcManageable& object,
                         const PHTimeStamp& time_stamp,
                         int id)
{
  bool kIsRead = false;

  emcGeometry& geometry = static_cast<emcGeometry&>(object);
  geometry.Reset();

  PdbStatus status = fBM->DBApplication()->startRead();

  if (!status)
    {
      std::cerr << "<E> emcOMGeometryT<" << BM::name()
                << ">::Read : cannot open a read transaction"
           << std::endl;
      fBM->DBApplication()->abort();
      return false;
    }

  if (id<0) id=1;

  PdbBankID bankID(id);
  std::string pdb_classname = "PdbEmcSecGeomBank";
  std::string basename = geometry.GetCategory();

  PdbCalBank* emcBank =
    fBM->BankManager()->fetchBank(pdb_classname.c_str(),
                                  bankID,
                                  basename.c_str(),
                                  const_cast<PHTimeStamp&>(time_stamp));

  if (!emcBank)
    {
      std::cerr << "<E> emcOMGeometryT<" << BM::name()
           << ">::Read : cannot fetch geometry for time = "
           << time_stamp << std::endl;
      fBM->DBApplication()->abort();
      return false;
    }


  kIsRead = true;

  size_t nsectors = emcBank->getLength();
  assert (nsectors > 0 && nsectors <= emcGeometry::MaxNumberOfSectors());
  PdbEmcSecGeom* pdbsec;

  std::vector<SecGeom> theSectors(nsectors);

  for ( size_t iS = 0; iS < nsectors; iS++ )
    {

      SecGeom& sec = theSectors[iS];

      pdbsec = static_cast<PdbEmcSecGeom*>(&(emcBank->getEntry(iS)));

      size_t nx, ny;
      double xs, ys;

      pdbsec->NxNy(nx, ny);
      sec.SetNxNy(nx, ny);

      pdbsec->TowerXYSize(xs, ys);
      sec.SetTowerXYSize(xs, ys);

      sec.SetDirectTransformation(pdbsec->RotationMatrix(),
                                  pdbsec->TranslationVector());

    } // iS

  geometry.Set(theSectors);

  bool status_commit = fBM->DBApplication()->commit();
  kIsRead = status_commit && kIsRead;

  delete emcBank;

  return kIsRead;
}


//_____________________________________________________________________________
template<class BM>
void
emcOMGeometryT<BM>::Reset(void)
{
  delete fGeometry;
  fGeometry = 0;
}

//_____________________________________________________________________________
template<class BM>
bool
emcOMGeometryT<BM>::Write(const emcManageable& object,
                          const PHTimeStamp&,int)
{
  bool kWritten = false;

  const emcGeometry& cgeometry = static_cast<const emcGeometry&>(object);
  emcGeometry& geometry = const_cast<emcGeometry&>(cgeometry);

  // Start a write transaction
  PdbStatus status = fBM->DBApplication()->startUpdate();

  if (!status)
    {
      if ( DM()->GetVerboseLevel() )
        {
          std::cerr << "<E> emcOMGeometryT<" << BM::name()
                    << ">::Write : cannot open a write "
                    << "transaction to Objy" << std::endl;
          fBM->DBApplication()->abort();
          return false;
        }
    }

  PdbCalBank* emcBank = 0;
  PdbBankID bankID(1);
  PHTimeStamp begin, end;

  std::string pdb_classname = "PdbEmcSecGeomBank";
  std::string description = "Written by emcOMGeometry";
  std::string basename = geometry.GetCategory();
  begin = geometry.GetStartValTime();
  end = geometry.GetEndValTime();

  // Here we must update all other banks valid at that time
  // to fix their end-of-validity time to calfem->GetStartValTime()-epsilon
  // >>
  PHTimeStamp the_new_end;
  the_new_end = begin;
  the_new_end -= 1;

  size_t nupdate = 0;

  PdbBankList bankList;
  fBM->BankManager()->fetchAllBanks(bankList, pdb_classname.c_str(), bankID, basename.
                               c_str(), begin);
  PdbBankListIterator iter(bankList);
  PdbCalBank* bank;
  while ( (bank = iter()) )
    {
      // we only update banks which are not the very same one
      bool same = (bank->getEndValTime() == end && bank->getStartValTime() == begin)
        ;
      if (!same)
        {
          assert (end >= bank->getEndValTime());
          // splitting of bank headers is not (yet) supported...
          bank->setEndValTime(the_new_end);
          nupdate++;
        }
    }
  if ( DM()->GetVerboseLevel() )
    {
      std::cout << "<I> emcOMGeometryT<" << BM::name() 
                << ">::Write : " << nupdate
                << " updated banks." << std::endl;
    }
  // <<

  emcBank = fBM->BankManager()->createBank(pdb_classname.c_str(),
                                           bankID,
                                           description.c_str(),
                                           begin, end,
                                           basename.c_str());

  assert(emcBank != 0);

  // emcBank is a set of PdbEmcSecGeom :

  emcBank->setLength(geometry.NumberOfSectors());

  PdbEmcSecGeom* pdbsec;

  for ( size_t iS = 0; iS < geometry.NumberOfSectors(); iS++ )
    {
      const SecGeom& sec = geometry.Sector(iS);

      pdbsec = static_cast<PdbEmcSecGeom*>(&(emcBank->getEntry(iS)));

      pdbsec->SetNxNy(sec.nx(), sec.ny());
      pdbsec->SetTowerXYSize(sec.Tower_xSize(), sec.Tower_ySize());
      const PHMatrix& mat = sec.RotationMatrix();
      const PHVector& vec = sec.TranslationVector();
      pdbsec->SetTransformation(mat, vec);

    } // iS

  status = fBM->DBApplication()->commit();

  if (status)
    {
      kWritten = true;
    }
  else
    {
      std::cerr << "<E> emcOMGeometryT<" << BM::name() 
                << ">::Write : commit failed ?!" << std::endl;
      kWritten = false;
    }

  delete emcBank;

  return kWritten;
}

#endif