PisaServer.C

Go to the documentation of this file.

#include "PisaServer.h"

#include <cassert>
#include <cstdlib>
#include <iostream>

#include "TGeoManager.h"
#include "TLorentzVector.h"
#include "TMCVerbose.h"
#include "TROOT.h"
#include "TVirtualMC.h"

#include "PHCompositeNode.h"
#include "PHIODataNode.h"
#include "phool.h"

#include "PisaDevice.h"
#include "PisaHelper.h"
#include "PisaPhnxParv1.h"
#include "PisaStackv1.h"

ClassImp(PisaServer)

namespace
{
  std::string upperCase(const char* name)
  {
    std::string value = name;

    std::transform(value.begin(), value.end(), value.begin(), 
                   (int(*)(int))std::toupper);
    return value;
  }
}

//_____________________________________________________________________________
PisaServer*
PisaServer::instance()
{ 
  static PisaServer* ps = new PisaServer;
  return ps;
}

//_____________________________________________________________________________
PisaServer::PisaServer()
  : TVirtualMCApplication("PisaServer","PISA VirtualMC Application"),
    fVerbose(new TMCVerbose(0))
{
}

//_____________________________________________________________________________
PisaServer::~PisaServer()
{
  delete fVerbose;
  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      delete fDevices[i];
    }
}

//_____________________________________________________________________________
void
PisaServer::makeStack(PHCompositeNode* pisanode)
{
  PisaStack* stack = new PisaStackv1;

  PHIODataNode<PisaStack>* stackNode =
    new PHIODataNode<PisaStack>(stack,"Stack");

  pisanode->addNode(stackNode);
}

//_____________________________________________________________________________
bool
PisaServer::hasSubsystem(const char* subsystemname) const
{
  std::string name = upperCase(subsystemname);

  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      std::string dname = upperCase(fDevices[i]->subsystem());
      if ( dname == name )
        {
          return true;
        }
    }
  return false;
}

//_____________________________________________________________________________
void
PisaServer::Init(PHCompositeNode* topnode)
{
  gROOT->LoadMacro("PISAConfig.C");
  gROOT->ProcessLine("PISAConfig()");

  fVerbose->InitMC();

  fTopNode = topnode;

  fTopNode->addNode(new PHCompositeNode("PISA"));

  PHCompositeNode* pisanode = PisaHelper::getPisaNode(topnode);
  assert(pisanode!=0);

  readPhnxPar(pisanode);

  makeStack(pisanode);

  gMC->Init(); // this will call ConstructGeometry

  gMC->BuildPhysics();
}

//_____________________________________________________________________________
void
PisaServer::FinishRun()
{
  fVerbose->FinishRun();

  // write output to root/phool
}

//_____________________________________________________________________________
void
PisaServer::ConstructGeometry()
{
  fVerbose->ConstructGeometry();

  std::cout << PHWHERE << "# of devices=" << fDevices.size() << std::endl;

  // Ask this now so we insure we create *our* geometry manager, before
  // it gets created automatically by any call to TGeo*** (e.g. Material)
  // in some subsystem code.
  TGeoManager* gm = PisaHelper::getGeoManager();

  assert(gGeoManager!=0);

  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      fDevices[i]->createMaterials(fTopNode);
      fDevices[i]->createGeometry(fTopNode);
    }

  TGeoVolume* top = gGeoManager->GetVolume("HALL");
  if (!top)
    {
      std::cerr << PHWHERE << "Did not find HALL top mother volume."
                << "Something is seriously wrong. Aborting now."
                << std::endl;
      exit(1);
    }

  // Set the top volume.
  gm->SetTopVolume(top);

  // close geometry
  gm->CloseGeometry();
 
  // notify VMC about Root geometry
  gMC->SetRootGeometry();
  std::cout << "I called SetRootGeometry" << std::endl;
}

//_____________________________________________________________________________
void
PisaServer::InitGeometry()
{
  fVerbose->InitGeometry();

  //fCalorimeterSD->Initialize();
}

//_____________________________________________________________________________
void
PisaServer::GeneratePrimaries()
{
  // The generation of primaries is not done here.
  // It must have been done at an upper level, typically by
  // a SubsysReco and/or an InputManager which have to fill
  // the PISA/Stack node object.

  fVerbose->GeneratePrimaries(); // Track ID (filled by stack)

  PisaStack* stack = PisaHelper::getClass<PisaStack>(fTopNode,"Stack");
  assert(stack!=0);
  assert(stack->stack()!=0);

  gMC->SetStack(stack->stack());
 
  std::cout << PHWHERE << "Nprimary=" << stack->stack()->GetNprimary()
            << std::endl;
}

//_____________________________________________________________________________
void
PisaServer::BeginEvent()
{
  fVerbose->BeginEvent();

  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      fDevices[i]->beginEvent(fTopNode);
    }
}

//_____________________________________________________________________________
void
PisaServer::BeginPrimary()
{
  fVerbose->BeginPrimary();
}

//_____________________________________________________________________________
void
PisaServer::PostTrack()
{
  fVerbose->PostTrack();
}

//_____________________________________________________________________________
void
PisaServer::PreTrack()
{
  fVerbose->PreTrack();
}

//_____________________________________________________________________________
void
PisaServer::registerDevice(PisaDevice* device)
{
  fDevices.push_back(device);
}

//_____________________________________________________________________________
void
PisaServer::process_event(PHCompositeNode* topnode)
{  
  fVerbose->RunMC(1);

  assert(topnode==fTopNode);

  gMC->ProcessRun(1);
}

//_____________________________________________________________________________
void
PisaServer::Stepping()
{
  fVerbose->Stepping();

  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      if ( fDevices[i]->isSensitive() )
        {
          if ( fVerbosity )
            {
              std::cout << "PisaServer::Stepping: Calling stepManager of "
                        << fDevices[i]->name()
                        << std::endl;
            }
          fDevices[i]->stepManager();
        }
      else
        {
          if ( fVerbosity )
            {
              std::cout << "PisaServer::Stepping: Skipping stepManager of "
                        << fDevices[i]->name()
                        << std::endl;
            }
        }
    }
}

//_____________________________________________________________________________
void
PisaServer::FinishPrimary()
{
  fVerbose->FinishPrimary();
}

//_____________________________________________________________________________
void
PisaServer::FinishEvent()
{
  fVerbose->FinishEvent();

  for ( size_t i = 0; i < fDevices.size(); ++i )
    {
      fDevices[i]->finishEvent(fTopNode);
    }
}

//_____________________________________________________________________________
void
PisaServer::Field(const Double_t*, Double_t* b) const
{
  for (size_t i = 0; i < 3; ++i)
      {
        b[i] = 0.0;
      }
}

//_____________________________________________________________________________
void
PisaServer::readPhnxPar(PHCompositeNode* pisanode)
{
  PisaPhnxPar* parfile = new PisaPhnxParv1("phnx.par");

  PHIODataNode<PisaPhnxPar>* phnxparNode = 
    new PHIODataNode<PisaPhnxPar>(parfile,
                                  "PHNXPAR",
                                  "PHObject");
  pisanode->addNode(phnxparNode);
}

//_____________________________________________________________________________
int
PisaServer::verbosity() const
{
  return fVerbosity;
}

//_____________________________________________________________________________
void
PisaServer::verbosity(int verbosity)
{
  fVerbose->SetLevel(verbosity);
  fVerbosity = verbosity;
}