target_factory.F90

Go to the documentation of this file.

!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
!!
!! This program is free software; you can redistribute it and/or modify
!! it under the terms of the GNU General Public License as published by
!! the Free Software Foundation; either version 2, or (at your option)
!! any later version.
!!
!! This program is distributed in the hope that it will be useful,
!! but WITHOUT ANY WARRANTY; without even the implied warranty of
!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!! GNU General Public License for more details.
!!
!! You should have received a copy of the GNU General Public License
!! along with this program; if not, write to the Free Software
!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
!! 02110-1301, USA.
!!
 
#include "global.h"
 
module target_factory_oct_m
  use debug_oct_m
  use epot_oct_m
  use global_oct_m
  use grid_oct_m
  use ions_oct_m
  use, intrinsic :: iso_fortran_env
  use kpoints_oct_m
  use messages_oct_m
  use multicomm_oct_m
  use namespace_oct_m
  use opt_control_global_oct_m
  use opt_control_state_oct_m
  use parser_oct_m
  use profiling_oct_m
  use restart_oct_m
  use space_oct_m
  use states_elec_oct_m
  use target_oct_m
  use target_classical_oct_m
  use target_density_oct_m
  use target_excited_oct_m
  use target_exclude_oct_m
  use target_ground_state_oct_m
  use target_gstransformation_oct_m
  use target_hhg_oct_m
  use target_local_oct_m
  use target_spin_oct_m
  use target_tdlocal_oct_m
  use target_userdefined_oct_m
  use target_velocity_oct_m
  use td_oct_m
  use types_oct_m
  use varinfo_oct_m
 
  implicit none
 
  private
  public :: target_factory_create
 
contains
 
  ! ----------------------------------------------------------------------
  function target_factory_create(gr, kpoints, namespace, space, ions, qcs, td, w0, oct, ep, mc) result(tg)
    type(grid_t),                intent(in)    :: gr
    type(kpoints_t),             intent(in)    :: kpoints
    type(namespace_t),           intent(in)    :: namespace
    class(space_t),              intent(in)    :: space
    type(ions_t),                intent(in)    :: ions
    type(opt_control_state_t),   intent(inout) :: qcs
    type(td_t),                  intent(in)    :: td
    real(real64),                intent(in)    :: w0
    type(oct_t),                 intent(in)    :: oct
    type(epot_t),                intent(inout) :: ep
    type(multicomm_t),           intent(in)    :: mc
    class(target_t),             pointer       :: tg
 
    integer :: ierr, target_kind
    type(states_elec_t), pointer :: stin
    type(restart_t) :: restart
 
    push_sub(target_factory_create)
 
    stin => opt_control_point_qs(qcs)
 
    !%Variable OCTTargetOperator
    !%Type integer
    !%Section Calculation Modes::Optimal Control
    !%Default oct_tg_gstransformation
    !%Description
    !% The variable <tt>OCTTargetOperator</tt> prescribes which kind of target functional is
    !% to be used.
    !%Option oct_tg_groundstate 1
    !% The target operator is a projection operator on the ground state, <i>i.e.</i> the
    !% objective is to populate the ground state as much as possible.
    !%Option oct_tg_excited 2
    !% (Experimental) The target operator is an "excited state". This means that the target operator
    !% is a linear combination of Slater determinants, each one formed by replacing
    !% in the ground-state Slater determinant one occupied state with one excited
    !% state (<i>i.e.</i> "single excitations"). The description of which excitations are
    !% used, and with which weights, should be given in a file called
    !% <tt>oct-excited-state-target</tt>.
    !% See the documentation of subroutine <tt>excited_states_elec_init</tt> in the source
    !% code in order to use this feature.
    !%Option oct_tg_gstransformation 3
    !% The target operator is a projection operator on a transformation of the ground-state
    !% orbitals defined by the block <tt>OCTTargetTransformStates</tt>.
    !%Option oct_tg_userdefined 4
    !% (Experimental) Allows to define target state by using <tt>OCTTargetUserdefined</tt>.
    !%Option oct_tg_jdensity 5
    !% (Experimental)
    !%Option oct_tg_local 6
    !% (Experimental) The target operator is a local operator.
    !%Option oct_tg_td_local 7
    !% (Experimental) The target operator is a time-dependent local operator.
    !%Option oct_tg_exclude_state 8
    !% (Experimental) Target operator is the projection onto the complement of a given state, given by the
    !% block <tt>OCTTargetTransformStates</tt>. This means that the target operator is the unity
    !% operator minus the projector onto that state.
    !%Option oct_tg_hhg 9
    !% (Experimental) The target is the optimization of the HHG yield. You must supply the <tt>OCTOptimizeHarmonicSpectrum</tt>
    !% block, and it attempts to optimize the maximum of the spectrum around each harmonic peak. You may
    !% use only one of the gradient-less optimization schemes.
    !%Option oct_tg_velocity 10
    !% (Experimental) The target is a function of the velocities of the nuclei at the end of the influence of
    !% the external field, defined by <tt>OCTVelocityTarget</tt>
    !%Option oct_tg_hhgnew 12
    !% (Experimental) The target is the optimization of the HHG yield. You must supply the
    !% <tt>OCTHarmonicWeight</tt> string. It attempts to optimize the integral of the harmonic spectrum multiplied
    !% by some user-defined weight function.
    !%Option oct_tg_classical 13
    !% (Experimental)
    !%Option oct_tg_spin 14
    !% (Experimental)
    !%End
    call parse_variable(namespace, 'OCTTargetOperator', oct_tg_gstransformation, target_kind)
    if (target_kind == oct_tg_excited) call messages_experimental('OCTTargetOperator = oct_tg_excited', namespace=namespace)
    if (target_kind == oct_tg_userdefined) call messages_experimental('OCTTargetOperator = oct_tg_userdefined')
    if (target_kind == oct_tg_jdensity) call messages_experimental('OCTTargetOperator = oct_tg_jdensity', namespace=namespace)
    if (target_kind == oct_tg_local) call messages_experimental('OCTTargetOperator = oct_tg_local', namespace=namespace)
    if (target_kind == oct_tg_td_local) call messages_experimental('OCTTargetOperator = oct_tg_td_local', namespace=namespace)
    if (target_kind == oct_tg_exclude_state) &
      call messages_experimental('OCTTargetOperator = oct_tg_exclude_state', namespace=namespace)
    if (target_kind == oct_tg_hhg) call messages_experimental('OCTTargetOperator = oct_tg_hhg', namespace=namespace)
    if (target_kind == oct_tg_velocity) call messages_experimental('OCTTargetOperator = oct_tg_velocity', namespace=namespace)
    if (target_kind == oct_tg_hhgnew) call messages_experimental('OCTTargetOperator = oct_tg_hhgnew', namespace=namespace)
    if (target_kind == oct_tg_classical) call messages_experimental('OCTTargetOperator = oct_tg_classical', namespace=namespace)
    if (target_kind == oct_tg_spin) call messages_experimental('OCTTargetOperator = oct_tg_spin', namespace=namespace)
 
    if (.not. varinfo_valid_option('OCTTargetOperator', target_kind)) then
      call messages_input_error(namespace, 'OCTTargetOperator')
    end if
 
    select case (target_kind)
    case (oct_tg_groundstate)
      allocate(target_ground_state_t :: tg)
    case (oct_tg_excited)
      allocate(target_excited_t :: tg)
    case (oct_tg_exclude_state)
      allocate(target_exclude_t :: tg)
    case (oct_tg_gstransformation)
      allocate(target_gstransformation_t :: tg)
    case (oct_tg_userdefined)
      allocate(target_userdefined_t :: tg)
    case (oct_tg_jdensity)
      allocate(target_density_t :: tg)
    case (oct_tg_local)
      allocate(target_local_t :: tg)
    case (oct_tg_td_local)
      allocate(target_tdlocal_t :: tg)
    case (oct_tg_hhg)
      allocate(target_hhg_t :: tg)
    case (oct_tg_hhgnew)
      allocate(target_hhgnew_t :: tg)
    case (oct_tg_velocity)
      allocate(target_velocity_t :: tg)
    case (oct_tg_classical)
      allocate(target_classical_t :: tg)
    case (oct_tg_spin)
      allocate(target_spin_t :: tg)
    case default
      write(message(1),'(a)') "Target Operator not properly defined."
      call messages_fatal(1, namespace=namespace)
    end select
 
    ! Common initialization shared by every target kind.
    tg%type = target_kind
    tg%move_ions = .false.
    tg%curr_functional = oct_no_curr
 
    call states_elec_copy(tg%st, stin)
    call states_elec_deallocate_wfns(tg%st)
    call states_elec_allocate_wfns(tg%st, gr, type_cmplx)
    call restart%init(namespace, restart_gs, restart_type_load, mc, ierr, mesh=gr, exact=.true.)
    if (ierr /= 0) then
      message(1) = "Could not read gs for OCTTargetOperator."
      call messages_fatal(1, namespace=namespace)
    end if
 
    call tg%init(gr, kpoints, namespace, space, ions, qcs, td, w0, oct, ep, restart)
 
    call restart%end()
 
    nullify(stin)
    pop_sub(target_factory_create)
  end function target_factory_create
  ! ----------------------------------------------------------------------
 
end module target_factory_oct_m
 
!! Local Variables:
!! mode: f90
!! coding: utf-8
!! End: